diff --git a/.gitignore b/.gitignore index 0569c35b..5504fb68 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,4 @@ - -# hlvs controller files +# HLVS controller files controllers/player/build controllers/model_verifier/results/* controllers/referee/meshes/* @@ -12,6 +11,8 @@ controllers/model_verifier/results/* controllers/model_verifier/model_verifier.log controllers/model_verifier/report.md +# Game controller files +GameController/ # Python compiled files *.pyc @@ -22,4 +23,169 @@ __pycache__/ *.wbproj # IDEs -.idea/* +.idea/ +.vscode/ + +# Default python gitignore: +########################### + +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/#use-with-ide +.pdm.toml + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# PyCharm +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can +# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore +# and can be added to the global gitignore or merged into this file. For a more nuclear +# option (not recommended) you can uncomment the following to ignore the entire idea folder. +#.idea/ diff --git a/README.md b/README.md index 83296ec8..88c315a1 100644 --- a/README.md +++ b/README.md @@ -7,21 +7,31 @@ This folder contains the simulation setup for the Robocup Virtual Humanoid Leagu In order to run this simulation, you will need to have a [fairly powerful](https://cyberbotics.com/doc/guide/system-requirements) Linux, Windows or macOS computer. You will also need to get familiar with Webots by reading the [Webots User Guide](https://cyberbotics.com/doc/guide/) and following the [Tutorials](https://cyberbotics.com/doc/guide/tutorials). -## Installation +## Installation for Ubuntu (tested with 22.04) -1. Install Webots 2022b from https://cyberbotics.com/ +1. Install Webots 2022b from 2. Build the latest version of the official RoboCup Humanoid TC fork of the [GameController](https://github.com/RoboCup-Humanoid-TC/GameController). + ``` apt-get install ant git clone https://github.com/RoboCup-Humanoid-TC/GameController cd GameController ant ``` + 3. Install Python dependencies: - ``` - pip3 install -r controllers/referee/requirements.txt - ``` + + - Main dependencies: + ``` + pip3 install -r controllers/referee/requirements/common.txt + ``` + - Optional development dependencies: + ``` + pip3 install -r controllers/referee/requirements/dev.txt + ``` + 4. Build the controllers: + ``` apt-get install protobuf-compiler libprotobuf-dev libjpeg9-dev export WEBOTS_HOME=/usr/local/webots # Set WEBOTS_HOME. This might be a different location, depending on your installation type @@ -31,9 +41,11 @@ You will also need to get familiar with Webots by reading the [Webots User Guide ## Run the Demo 1. Open the [robocup.wbt](worlds/robocup.wbt) world file in Webots and run it until you see the GameController window showing up. + ``` GAME_CONTROLLER_HOME=/path/to/GameController JAVA_HOME=/usr webots ./worlds/robocup.wbt ``` + You have to pass the environment variables `GAME_CONTROLLER_HOME` which points to the `GameController` folder and `JAVA_HOME` which points to your Java installation (which might be under `/usr`). 2. You can manually move the robots and the ball using the mouse (Shift-right-click-and-drag). 3. Launch the sample robot controller [client.cpp](controllers/player/client.cpp) by typing `./client` in the [controllers/player](controllers/player) folder. @@ -42,13 +54,13 @@ You will also need to get familiar with Webots by reading the [Webots User Guide ## Modify the Game and Teams Configuration 1. Quit Webots. -2. Edit the [game.json](controllers/referee/game.json) file to change the game configuration. The ports in this file are where the API server will open ports and the API servers will only accept traffic from the whitelisted IP, i.e. you might want to change the IPs to 127.0.0.1 for a local setup. +2. Edit the [game.json](controllers/referee/game.json) (see [here](#configuration-of-gamejson) for details on configuration) file to change the game configuration. The ports in this file are where the API server will open ports and the API servers will only accept traffic from the whitelisted IP, i.e. you might want to change the IPs to 127.0.0.1 for a local setup. 3. Edit the [team_1.json](controllers/referee/team_1.json) and [team_2.json](controllers/referee/team_2.json) files to change the teams configuration. 4. Restart the simulation. ## Program your Own Robot Controllers -1. Update the [game.json](controllers/referee/game.json) configuration file and create your own team configuration files, taking inspiration from [team_1.json](controllers/referee/team_1.json) and [team_2.json](controllers/referee/team_2.json). +1. Update the [game.json](controllers/referee/game.json) configuration file (see [here](#configuration-of-gamejson) and create your own team configuration files, taking inspiration from [team_1.json](controllers/referee/team_1.json) and [team_2.json](controllers/referee/team_2.json). 2. Create your own robot controllers, taking inspiration from the sample [client.cpp](controllers/player/client.cpp). ## Create your Own Robot Model @@ -133,23 +145,50 @@ A semi-automated tool allowing to check if a robot respects the rules is availab the `controllers/model_verifier` directory. The available scripts are documented in a dedicated [README](controllers/model_verifier/README.md). -## game.json settings - -Multiple variables can be set to influence the behavior of the simulation. - -`record_simulation:` a file path to where the simulation should be recorded. If it ends in `.html` a 3D recording is made. If it ends in `.mp4` a video from the default perspective is generated. - -`press_a_key_to_terminate`: true or false, allows pressing a key to cleanly end the simulation and save the recording (used for testing) - -`game_controller_extra_args`: used to pass arguments to the game controller, for example -```json - "game_controller_extra_args": [ - "--halftimeduration", - "120", - "--overtimeduration", - "60" - ], -``` -can be used to reduce halftime duration. - -`texture_seed`: can be set to an integer to set the random seed used for texture (background, background luminosity, and ball) +## Configuration of `game.json` + +Configuration that is game-specific is defined in the `game.json` file. +This configuration is used by the referee (and by the udp_bouncer if it is used). + +### Required fields + +- `type`: Type of the game [`NORMAL`, `KNOCKOUT`. `PENALTY`] +- `class`: Subleague of the game [`kid`, `adult`] +- `kickoff`: Color of the team that has kickoff at the start of the game [`red`, `blue`] +- `side_left`: Color of the team that starts on the left field side [`red`, `blue`] +- `host`: IP of the machine the referee is running on [LAN IP, or `127.0.0.1` for local] +- `maximum_real_time_factor`: Referee guarantees that the simulation is not running faster. Values <= 0.0 mean, the simulation can run as fast as possible [float] +- `data_collection`: Configuration for data collection + - `enabled`: Whether to enable the data collection [`true` or `false`] + - `directory`: Path to directory where to store data collection files + - `step_interval`: Interval between data collection steps, so it only runs every `step_interval` steps [integer] + - `autosave_interval`: Automatically saves collected data every `autosave_interval` seconds during the game. Set to -1 to disable auto save [integer] +- `red`: Configuration for the red team + - `id`: ID of the red team + - `config`: (Relative) Path to the configuration file of the red team + - `hosts`: List of IPs of the red team robots' machines + - `ports`: List of ports of the red team robots' machines +- `blue`: Configuration for the blue team + - `id`: ID of the blue team + - `config`: (Relative) Path to the configuration file of the blue team + - `hosts`: List of IPs of the blue team robots' machines + - `ports`: List of ports of the blue team robots' machines + +### Optional fields + +Some fields are optional, but can be used to influence the behavior of the simulation. + +- `press_a_key_to_terminate`: Allows pressing a key to cleanly end the simulation and save the recording (used for testing) [`true` or `false`] +- `use_bouncing_server`: Whether to use the udp_bouncer [`true` or `false`] +- `record_simulation:` File path to where the simulation should be recorded. If it ends in `.html` a 3D recording is made. If it ends in `.mp4` a video from the default perspective is generated. +- `max_duration`: Maximum duration of the game in real-time seconds [integer] +- `texture_seed`: Seed used for pseudo-random selection of textures (background, background luminosity, and ball) [integer] +- `game_controller_extra_args`: Pass arguments to the game controller, for example + ```json + "game_controller_extra_args": [ + "--halftimeduration", + "120", + "--overtimeduration", + "60" + ], + ``` diff --git a/controllers/referee/data_collection/README.md b/controllers/referee/data_collection/README.md new file mode 100644 index 00000000..4e1a8532 --- /dev/null +++ b/controllers/referee/data_collection/README.md @@ -0,0 +1,711 @@ +# Data Collection + +## Data Structure + +```mermaid +--- +title: DataCollection complete UML class diagram +--- +classDiagram + class DataCollector { + +save_dir: os.PathLike + +autosave_interval: int + +match: Match + +logger: Optional[Logger] + +__init__(save_dir, autosave_interval, match, logger) + +finalize() + +create_new_step(int time) + +current_step() Step + #_autosave(...) + } + + class Match { + #_static: StaticMatchInfo + #_steps: List[Step] + +__init__(static) + +get_static_match_info() StaticMatchInfo + +get_steps() List[Step] + +add_step(step: Step) + +current_step() Step + +save(save_dir: os.PathLike, file_name: str) + } + + class StaticMatchInfo { + +id: str + +match_type: MatchType + +league_sub_type: LeagueSubType + +simulation: Simulation + +field: Field + +ball: StaticBall + +teams: StaticTeams + +kick_off_team: str + +version: str + } + + class MatchType { + <> + UNKNOWN: int + ROUNDROBIN: int + PLAYOFF: int + DROPIN: int + PENALTY: int + } + + class LeagueSubType { + <> + KID: str + ADULT: str + } + + class StaticBall { + +id: str + +mass: float + +texture: str + +diameter: float + } + + class Field { + +location_id: str + +location_name: str + +size_x: float + +size_y: float + +luminosity: Optional[float] + +friction: Optional[float] + +natural_light: Optional[bool] + +weather: Optional[str] + } + + class Simulation { + +is_simulated: bool + +basic_time_step: int + +data_collection_interval: int + } + + class StaticTeams { + +team1: StaticTeam + +team2: StaticTeam + +get_teams() Tuple[StaticTeam, StaticTeam] + +get_team_by_id(id: str) StaticTeam + +get_team_by_color(color: TeamColor) StaticTeam + +red() StaticTeam + +blue() StaticTeam + +get_team_by_name(name: str) StaticTeam + } + + class StaticTeam { + +id: str + +name: str + +color: TeamColor + +player1: StaticPlayer + +player2: StaticPlayer + +player3: StaticPlayer + +player4: StaticPlayer + } + + class TeamColor { + <> + BLUE: int + RED: int + YELLOW: int + BLACK: int + WHITE: int + GREEN: int + ORANGE: int + PURPLE: int + BROWN: int + GRAY: int + } + + class StaticMatchObject { + +id: str + +mass: float + } + + class StaticPlayer { + +id: str + +mass: float + +DOF: int + +platform: str + +mono_camera: Optional[Camera] + +stereo_camera_l: Optional[Camera] + +stereo_camera_r: Optional[Camera] + } + + class Camera { + +frame_id: str + +FPS: float + +FOV: float + +pixel_count_x: int + +pixel_count_y: int + } + + class Step { + +time: float + +delta_real_time: Optional[float] + +game_control_data: Optional[GameControlData] + +ball: Optional[Ball] + +teams: Optional[Teams] + } + + class GameControlData { + +game_state: GameState + +first_half: bool + +kickoff_team: int + +secondary_state: SecondaryGameState + +secondary_state_info_team: int + +secondary_state_info_sub_state: int + +drop_in_team: bool + +drop_in_time: int + +seconds_remaining: int + +secondary_seconds_remaining: int + } + + class GameState { + <> + STATE_INITIAL: int + STATE_READY: int + STATE_SET: int + STATE_PLAYING: int + STATE_FINISHED: int + } + + class SecondaryGameState { + <> + STATE_NORMAL: int + STATE_PENALTYSHOOT: int + STATE_OVERTIME: int + STATE_TIMEOUT: int + STATE_DIRECT_FREEKICK: int + STATE_INDIRECT_FREEKICK: int + STATE_PENALTYKICK: int + STATE_CORNERKICK: int + STATE_GOALKICK: int + STATE_THROWIN: int + STATE_DROPBALL: int + STATE_UNKNOWN: int + } + + class MatchObject { + +id: str + } + + class Ball { + +id: str + +frame: frame + } + + class Frame { + +id: str + +pose: Pose + } + + class Pose { + +position: Position + +rotation: Rotation + +pose_from_affine(affine: numpy.ndarray) Pose + } + + class Position { + +x: float + +y: float + +z: float + } + + class Rotation { + +x: float + +y: float + +z: float + +w: float + +quaternion() Tuple[float, float, float, float] + +rpy() Tuple[float, float, float] + } + + class Teams { + +team1: Team + +team2: Team + +get_teams() Tuple[Team, Team] + +get_team_by_id(id: str) Team + } + + class Team { + +id: str + +player1: Player + +player2: Player + +player3: Player + +player4: Player + +score: int + +penalty_shots: int + +single_shots: int + } + + class Player { + +id: str + +base_link: Frame + +l_sole: Frame + +r_sole: Frame + +l_gripper: Frame + +r_gripper: Frame + +camera_frame: Optional[Frame] + +l_camera_frame: Optional[Frame] + +r_camera_frame: Optional[Frame] + +state: State + +role: Role + +action: Action + +robot_info: Optional[RobotInfo] + +get_soles() Tuple[Frame, Frame] + +get_grippers() Tuple[Frame, Frame] + +get_stereo_camera_frames() Tuple[Optional[Frame], Optional[Frame]] + } + + class State { + <> + UNKNOWN_STATE: int + UNPENALISED: int + PENALISED: int + } + + class Role { + <> + ROLE_UNDEFINED: int + ROLE_IDLING: int + ROLE_OTHER: int + ROLE_STRIKER: int + ROLE_SUPPORTER: int + ROLE_DEFENDER: int + ROLE_GOALIE: int + } + + class Action { + <> + ACTION_UNDEFINED: int + ACTION_POSITIONING: int + ACTION_GOING_TO_BALL: int + ACTION_TRYING_TO_SCORE: int + ACTION_WAITING: int + ACTION_KICKING: int + ACTION_SEARCHING: int + ACTION_LOCALIZING: int + } + + class RobotInfo { + +penalty: Penalty + +secs_till_unpenalized: int + +number_of_warnings: int + +number_of_yellow_cards: int + +number_of_red_cards: int + +goalkeeper: bool + } + + class Penalty { + <> + UNKNOWN: int + NONE: int + SUBSTITUTE: int + MANUAL: int + HL_BALL_MANIPULATION: int + HL_PHYSICAL_CONTACT: int + HL_PICKUP_OR_INCAPABLE: int + HL_SERVICE: int + } + +DataCollector --> Match +Match --> StaticMatchInfo +Match --> Step +StaticMatchInfo --> MatchType +StaticMatchInfo --> LeagueSubType +StaticMatchInfo --> Simulation +StaticMatchInfo --> Field +StaticMatchInfo --> StaticBall +StaticMatchInfo --> StaticTeams +StaticBall <|-- StaticMatchObject +StaticPlayer <|-- StaticMatchObject +StaticTeams --> StaticTeam +StaticTeams --> TeamColor +StaticTeam --> TeamColor +StaticTeam --> StaticPlayer +StaticPlayer --> Camera +Step --> GameControlData +Step --> Ball +Step --> Teams +GameControlData --> GameState +GameControlData --> SecondaryGameState +MatchObject <|-- Ball +MatchObject <|-- Player +Ball --> Frame +Frame --> Pose +Pose --> Position +Pose --> Rotation +Teams --> Team +Team --> Player +Player --> Frame +Player --> State +Player --> Role +Player --> Action +Player --> RobotInfo +RobotInfo --> Penalty +``` + +```mermaid +--- +title: DataCollection high level UML class diagram +--- +classDiagram + class DataCollector { + +save_dir: os.PathLike + +autosave_interval: int + +match: Match + +logger: Optional[Logger] + +__init__(save_dir, autosave_interval, match, logger) + +finalize() + +create_new_step(int time) + +current_step() Step + #_autosave(...) + } + + class Match { + #_static: StaticMatchInfo + #_steps: List[Step] + +__init__(static) + +get_static_match_info() StaticMatchInfo + +get_steps() List[Step] + +add_step(step: Step) + +current_step() Step + +save(save_dir: os.PathLike, file_name: str) + } + + class StaticMatchInfo { + ... + } + + class Step { + ... + } + +DataCollector --> Match +Match --> StaticMatchInfo +Match --> Step +``` + +```mermaid +--- +title: DataCollection StaticMatchInfo detail UML class diagram +--- +classDiagram + class StaticMatchInfo { + +id: str + +match_type: MatchType + +league_sub_type: LeagueSubType + +simulation: Simulation + +field: Field + +ball: StaticBall + +teams: StaticTeams + +kick_off_team: str + +version: str + } + + class MatchType { + <> + UNKNOWN: int + ROUNDROBIN: int + PLAYOFF: int + DROPIN: int + PENALTY: int + } + + class LeagueSubType { + <> + KID: str + ADULT: str + } + + class StaticBall { + +id: str + +mass: float + +texture: str + +diameter: float + } + + class Field { + +location_id: str + +location_name: str + +size_x: float + +size_y: float + +luminosity: Optional[float] + +friction: Optional[float] + +natural_light: Optional[bool] + +weather: Optional[str] + } + + class Simulation { + +is_simulated: bool + +basic_time_step: int + +data_collection_interval: int + } + + class StaticTeams { + +team1: StaticTeam + +team2: StaticTeam + +get_teams() Tuple[StaticTeam, StaticTeam] + +get_team_by_id(id: str) StaticTeam + +get_team_by_color(color: TeamColor) StaticTeam + +red() StaticTeam + +blue() StaticTeam + +get_team_by_name(name: str) StaticTeam + } + + class StaticTeam { + +id: str + +name: str + +color: TeamColor + +player1: StaticPlayer + +player2: StaticPlayer + +player3: StaticPlayer + +player4: StaticPlayer + } + + class TeamColor { + <> + BLUE: int + RED: int + YELLOW: int + BLACK: int + WHITE: int + GREEN: int + ORANGE: int + PURPLE: int + BROWN: int + GRAY: int + } + + class StaticMatchObject { + +id: str + +mass: float + } + + class StaticPlayer { + +id: str + +mass: float + +DOF: int + +platform: str + +mono_camera: Optional[Camera] + +stereo_camera_l: Optional[Camera] + +stereo_camera_r: Optional[Camera] + } + + class Camera { + +frame_id: str + +FPS: float + +FOV: float + +pixel_count_x: int + +pixel_count_y: int + } + +StaticMatchInfo --> MatchType +StaticMatchInfo --> LeagueSubType +StaticMatchInfo --> Simulation +StaticMatchInfo --> Field +StaticMatchInfo --> StaticBall +StaticMatchInfo --> StaticTeams +StaticBall <|-- StaticMatchObject +StaticPlayer <|-- StaticMatchObject +StaticTeams --> StaticTeam +StaticTeams --> TeamColor +StaticTeam --> TeamColor +StaticTeam --> StaticPlayer +StaticPlayer --> Camera +``` + +```mermaid +--- +title: DataCollection Step detail UML class diagram +--- +classDiagram + class Step { + +time: float + +delta_real_time: Optional[float] + +game_control_data: Optional[GameControlData] + +ball: Optional[Ball] + +teams: Optional[Teams] + } + + class GameControlData { + +game_state: GameState + +first_half: bool + +kickoff_team: int + +secondary_state: SecondaryGameState + +secondary_state_info_team: int + +secondary_state_info_sub_state: int + +drop_in_team: bool + +drop_in_time: int + +seconds_remaining: int + +secondary_seconds_remaining: int + } + + class GameState { + <> + STATE_INITIAL: int + STATE_READY: int + STATE_SET: int + STATE_PLAYING: int + STATE_FINISHED: int + } + + class SecondaryGameState { + <> + STATE_NORMAL: int + STATE_PENALTYSHOOT: int + STATE_OVERTIME: int + STATE_TIMEOUT: int + STATE_DIRECT_FREEKICK: int + STATE_INDIRECT_FREEKICK: int + STATE_PENALTYKICK: int + STATE_CORNERKICK: int + STATE_GOALKICK: int + STATE_THROWIN: int + STATE_DROPBALL: int + STATE_UNKNOWN: int + } + + class MatchObject { + +id: str + } + + class Ball { + +id: str + +frame: frame + } + + class Frame { + +id: str + +pose: Pose + } + + class Pose { + +position: Position + +rotation: Rotation + +pose_from_affine(affine: numpy.ndarray) Pose + } + + class Position { + +x: float + +y: float + +z: float + } + + class Rotation { + +x: float + +y: float + +z: float + +w: float + +quaternion() Tuple[float, float, float, float] + +rpy() Tuple[float, float, float] + } + + class Teams { + +team1: Team + +team2: Team + +get_teams() Tuple[Team, Team] + +get_team_by_id(id: str) Team + } + + class Team { + +id: str + +player1: Player + +player2: Player + +player3: Player + +player4: Player + +score: int + +penalty_shots: int + +single_shots: int + } + + class Player { + +id: str + +base_link: Frame + +l_sole: Frame + +r_sole: Frame + +l_gripper: Frame + +r_gripper: Frame + +camera_frame: Optional[Frame] + +l_camera_frame: Optional[Frame] + +r_camera_frame: Optional[Frame] + +state: State + +role: Role + +action: Action + +robot_info: Optional[RobotInfo] + +get_soles() Tuple[Frame, Frame] + +get_grippers() Tuple[Frame, Frame] + +get_stereo_camera_frames() Tuple[Optional[Frame], Optional[Frame]] + } + + class State { + <> + UNKNOWN_STATE: int + UNPENALISED: int + PENALISED: int + } + + class Role { + <> + ROLE_UNDEFINED: int + ROLE_IDLING: int + ROLE_OTHER: int + ROLE_STRIKER: int + ROLE_SUPPORTER: int + ROLE_DEFENDER: int + ROLE_GOALIE: int + } + + class Action { + <> + ACTION_UNDEFINED: int + ACTION_POSITIONING: int + ACTION_GOING_TO_BALL: int + ACTION_TRYING_TO_SCORE: int + ACTION_WAITING: int + ACTION_KICKING: int + ACTION_SEARCHING: int + ACTION_LOCALIZING: int + } + + class RobotInfo { + +penalty: Penalty + +secs_till_unpenalized: int + +number_of_warnings: int + +number_of_yellow_cards: int + +number_of_red_cards: int + +goalkeeper: bool + } + + class Penalty { + <> + UNKNOWN: int + NONE: int + SUBSTITUTE: int + MANUAL: int + HL_BALL_MANIPULATION: int + HL_PHYSICAL_CONTACT: int + HL_PICKUP_OR_INCAPABLE: int + HL_SERVICE: int + } + +Step --> GameControlData +Step --> Ball +Step --> Teams +GameControlData --> GameState +GameControlData --> SecondaryGameState +MatchObject <|-- Ball +MatchObject <|-- Player +Ball --> Frame +Frame --> Pose +Pose --> Position +Pose --> Rotation +Teams --> Team +Team --> Player +Player --> Frame +Player --> State +Player --> Role +Player --> Action +Player --> RobotInfo +RobotInfo --> Penalty +``` diff --git a/controllers/referee/data_collection/__init__.py b/controllers/referee/data_collection/__init__.py new file mode 100644 index 00000000..a0c2e60e --- /dev/null +++ b/controllers/referee/data_collection/__init__.py @@ -0,0 +1 @@ +from .data_collector import DataCollector diff --git a/controllers/referee/data_collection/data_collector.py b/controllers/referee/data_collection/data_collector.py new file mode 100644 index 00000000..363a186f --- /dev/null +++ b/controllers/referee/data_collection/data_collector.py @@ -0,0 +1,138 @@ +import os +import time +from datetime import datetime +from threading import Event, Thread + +from data_collection import match_info as mi + +# from ..logger import Logger + + +class DataCollector: + def __init__( + self, + save_dir: os.PathLike, + autosave_interval: int, + match: mi.Match, + logger=None, + ) -> None: + """Initialize DataCollector. + :param save_dir: Path to directory where to store match data + :type save_dir: os.PathLike + :param autosave_interval: Interval in seconds to autosave match data. Set to -1 to disable autosave + :type autosave_interval: int + :param match: Match data + :type match: mi.Match + :param logger: Logger, defaults to None + :type logger: Optional[Logger], optional + """ + self.save_dir: os.PathLike = save_dir + self.logger = logger + self.match: mi.Match = match + + if not os.path.exists(save_dir): + os.makedirs(save_dir) + + self._finalized = ( + False # True, if finalized was successful, to prevent saving two times + ) + + self.autosave_interval: int = autosave_interval + if autosave_interval >= 0: + self.autosave_stop_tread_event: Event = Event() + self.autosave_thread: Thread = Thread( + target=self._autosave, + args=[ + self.autosave_stop_tread_event, + self.autosave_interval, + self.save_dir, + self.logger, + ], + ) + self.autosave_thread.start() + + def _close(self, filename_state: str): + """Stop autosave thread and save one last time manually. + + :param filename_state: State to include in save filenames (e.g. "COMPLETE", "FAILURE") + :type filename_state: str + """ + # Stop autosave thread + self.autosave_stop_tread_event.set() + self.autosave_thread.join() + + # Save match data + self.match.save( + self.save_dir, + f"referee_data_collection_{filename_state}_{datetime.utcnow().strftime('%Y-%m-%dT%H-%M-%S')}", + self.logger, + ) + + def __del__(self) -> None: # Cleanup in case of failures + if not self._finalized: + self._close("FAILURE") + + def finalize(self) -> None: + """Finalize the data collection and save to filesystem.""" + self._close("COMPLETE") + self._finalized = True + + def create_new_step(self, time: int) -> None: + """Creates a new empty step. + + :param time: Time of the step in milliseconds + :type time: int + """ + self.match.add_step(mi.Step(time=time)) + + def current_step(self) -> mi.Step: + """Get the current step. + + :return: Current step + :rtype: mi.Step + """ + return self.match.current_step() + + def _autosave( + self, + stop_event: Event, + autosave_interval: int, + save_dir: os.PathLike, + logger=None, + ) -> None: + """Saves match data automatically in AUTOSAVE_INTERVAL. + Old autosave files are being removed after new autosave was successful. + + :param stop_event: Event to stop autosave thread + :type stop_event: Event + :param autosave_interval: Interval in seconds to autosave match data + :type autosave_interval: int + :param save_dir: Path to directory where to store match data + :type save_dir: os.PathLike + :param logger: Logger, defaults to None + :type logger: Optional[Logger], optional + """ + previous_autosave_filename: str = "" # Path to last autosave filename + next_autosave_time: float = time.time() + autosave_interval + while not stop_event.is_set(): + # Sleep for shorter time than autosave interval to join thread faster + time.sleep(3) + now: float = time.time() + if now >= next_autosave_time: + next_autosave_time = now + autosave_interval + filename: str = f"referee_data_collection_AUTOSAVE_{datetime.utcnow().strftime('%Y-%m-%dT%H-%M-%S')}" + self.match.save(save_dir, filename, logger) + + # Remove previous autosave file + if previous_autosave_filename: + for extension in [".feather", ".pkl", ".json"]: + try: + os.remove( + os.path.join( + save_dir, previous_autosave_filename + extension + ) + ) + except FileNotFoundError: + pass + + previous_autosave_filename = filename diff --git a/controllers/referee/data_collection/match_info/__init__.py b/controllers/referee/data_collection/match_info/__init__.py new file mode 100644 index 00000000..3c4616bd --- /dev/null +++ b/controllers/referee/data_collection/match_info/__init__.py @@ -0,0 +1,13 @@ +from .ball import Ball, StaticBall +from .camera import Camera +from .field import Field +from .frame import Frame +from .match_object import MatchObject, StaticMatchObject +from .player import Action, Penalty, Player, RobotInfo, Role, State, StaticPlayer +from .pose import Pose, Position, Rotation, pose_from_affine +from .simulation import Simulation +from .static_match_info import LeagueSubType, MatchType, StaticMatchInfo +from .team import StaticTeam, StaticTeams, Team, TeamColor, Teams + +from .step import GameControlData, Step +from .match import Match diff --git a/controllers/referee/data_collection/match_info/ball.py b/controllers/referee/data_collection/match_info/ball.py new file mode 100644 index 00000000..62ea4fff --- /dev/null +++ b/controllers/referee/data_collection/match_info/ball.py @@ -0,0 +1,37 @@ +from dataclasses import dataclass + +from dataclasses_json import DataClassJsonMixin + +from .frame import Frame +from .match_object import MatchObject, StaticMatchObject + + +@dataclass(frozen=True) +class StaticBall(StaticMatchObject): + """Static information about a ball. + + :param id: Unique id of the ball object + :type id: str + :param mass: Mass of the ball in kg + :type mass: float + :param texture: Texture of the ball + :type texture: str + :param diameter: Diameter of the ball in meters + :type diameter: float + """ + + texture: str + diameter: float + + +@dataclass +class Ball(MatchObject, DataClassJsonMixin): + """Ball object. + + :param id: Unique id of the ball object + :type id: str + :param frame: Frame that are part of the ball object + :type frame: Frame + """ + + frame: Frame diff --git a/controllers/referee/data_collection/match_info/camera.py b/controllers/referee/data_collection/match_info/camera.py new file mode 100644 index 00000000..6a7e72a6 --- /dev/null +++ b/controllers/referee/data_collection/match_info/camera.py @@ -0,0 +1,31 @@ +from dataclasses import dataclass + +# class CameraMatrix: +# def __init__(self) -> None: +# pass +# +# def get_field_of_view(self, resolution: Tuple[int, int]) -> Tuple[float, float]: +# return (0.0, 0.0) # TODO + + +@dataclass(frozen=True) +class Camera: + """Static information about a camera. + + :param frame_id: Id of the frame that this camera is attached to + :type frame_id: str + :param FPS: Frames per second + :type FPS: float + :param FOV: Field of view of the camera + :type FOV: float + :param pixel_count_x: Number of pixels in x direction + :type pixel_count_x: int + :param pixel_count_y: Number of pixels in y direction + :type pixel_count_y: int + """ + + frame_id: str + FPS: float + FOV: float + pixel_count_x: int + pixel_count_y: int diff --git a/controllers/referee/data_collection/match_info/field.py b/controllers/referee/data_collection/match_info/field.py new file mode 100644 index 00000000..06feda03 --- /dev/null +++ b/controllers/referee/data_collection/match_info/field.py @@ -0,0 +1,34 @@ +from dataclasses import dataclass +from typing import Optional + + +@dataclass(frozen=True) +class Field: + """Static information about a field. + + :param location_id: Id of the location + :type location_id: str + :param location_name: Name of the location + :type location_name: str + :param size_x: Size of the field in x direction + :type size_x: float + :param size_y: Size of the field in y direction + :type size_y: float + :param luminosity: Luminosity of the field, defaults to None + :type luminosity: Optional[float], optional + :param friction: Friction of the field, defaults to None + :type friction: Optional[float], optional + :param natural_light: Whether the field has natural light, defaults to None + :type natural_light: Optional[bool], optional + :param weather: Weather of the field, defaults to None + :type weather: Optional[str], optional + """ + + location_id: str + location_name: str + size_x: float + size_y: float + luminosity: Optional[float] = None + friction: Optional[float] = None + natural_light: Optional[bool] = None + weather: Optional[str] = None diff --git a/controllers/referee/data_collection/match_info/frame.py b/controllers/referee/data_collection/match_info/frame.py new file mode 100644 index 00000000..73d2966c --- /dev/null +++ b/controllers/referee/data_collection/match_info/frame.py @@ -0,0 +1,19 @@ +from dataclasses import dataclass + +from dataclasses_json import DataClassJsonMixin + +from .pose import Pose + + +@dataclass(frozen=True) +class Frame(DataClassJsonMixin): + """Frame of a match object in 3D space. + + :param id: Unique id of the frame + :type id: str + :param pose: Pose of the frame + :type pose: Pose + """ + + id: str + pose: Pose diff --git a/controllers/referee/data_collection/match_info/match.py b/controllers/referee/data_collection/match_info/match.py new file mode 100644 index 00000000..0e140ea7 --- /dev/null +++ b/controllers/referee/data_collection/match_info/match.py @@ -0,0 +1,88 @@ +import os +from typing import List + +import pandas as pd + +from .static_match_info import StaticMatchInfo +from .step import Step + + +class Match: + def __init__(self, static: StaticMatchInfo) -> None: + """Holds static and dynamic data about a match. + + :param static: Static match info + :type static: StaticMatchInfo + """ + self._static: StaticMatchInfo = static + + self._steps: List[Step] = [] + + def get_static_match_info(self) -> StaticMatchInfo: + """Get the static match info. + + :return: Static match info + :rtype: StaticMatchInfo + """ + return self._static + + def get_steps(self) -> List[Step]: + """Get the steps of the match. + + :return: Steps of the match + :rtype: List[Step] + """ + return self._steps + + def add_step(self, step: Step) -> None: + """Add a step to the match. + + :param step: Step data + :type step: Step + """ + self._steps.append(step) + + def current_step(self) -> Step: + """Get the current step. + + :raises Exception: If there are no steps in the match + :return: Current step + :rtype: Step + """ + if len(self._steps) == 0: + raise Exception("No steps in match") + return self._steps[-1] + + def save( + self, + save_dir: os.PathLike, + file_name: str, + logger=None, + also_as_pickle: bool = True, + ) -> None: + """Save match as a dataframe to filesystem. + + :param save_dir: Path to directory where to store match data + :type save_dir: os.PathLike + :param file_name: Name under which to store the match data (without file extension) + :type file_name: str + :param logger: Logger, defaults to None + :type logger: Optional[Logger], optional + :param also_as_pickle: Whether dynamic match data should also be saved as a pickle file, defaults to True + :type also_as_pickle: bool, optional + """ + if logger: + logger.info(f"Saving data collection to '{save_dir}' as '{file_name}.*'...") + + # Save static match info + json_data: str = self.get_static_match_info().to_json() + with open(os.path.join(save_dir, file_name + ".json"), "w") as f: + f.write(json_data) + + # Save dynamic match info + steps = self.get_steps() + if steps: + df: pd.DataFrame = pd.json_normalize([step.to_dict() for step in steps]) + df.to_feather(os.path.join(save_dir, file_name + ".feather")) + if also_as_pickle: + df.to_pickle(os.path.join(save_dir, file_name + ".pkl")) diff --git a/controllers/referee/data_collection/match_info/match_object.py b/controllers/referee/data_collection/match_info/match_object.py new file mode 100644 index 00000000..a1bdfa9c --- /dev/null +++ b/controllers/referee/data_collection/match_info/match_object.py @@ -0,0 +1,26 @@ +from dataclasses import dataclass + + +@dataclass(frozen=True) +class StaticMatchObject: + """Static information about a match object. + + :param id: Unique id of the object + :type id: str + :param mass: Mass of the object in kg + :type mass: float + """ + + id: str + mass: float + + +@dataclass +class MatchObject: + """Match object. + + :param id: Unique id of the object + :type id: str + """ + + id: str diff --git a/controllers/referee/data_collection/match_info/player.py b/controllers/referee/data_collection/match_info/player.py new file mode 100644 index 00000000..a10ab9db --- /dev/null +++ b/controllers/referee/data_collection/match_info/player.py @@ -0,0 +1,172 @@ +from dataclasses import dataclass +from enum import IntEnum, unique +from typing import Optional, Tuple + +from dataclasses_json import DataClassJsonMixin + +from .camera import Camera +from .frame import Frame +from .match_object import MatchObject, StaticMatchObject + + +@unique +class State(IntEnum): + """Enum for player states.""" + + UNKNOWN_STATE = 0 + UNPENALISED = 1 + PENALISED = 2 + + +@unique +class Role(IntEnum): + """Enum for player roles.""" + + ROLE_UNDEFINED = 0 + ROLE_IDLING = 1 + ROLE_OTHER = 2 + ROLE_STRIKER = 3 + ROLE_SUPPORTER = 4 + ROLE_DEFENDER = 5 + ROLE_GOALIE = 6 + + +@unique +class Action(IntEnum): + """Enum for the current action of the robot.""" + + ACTION_UNDEFINED = 0 + ACTION_POSITIONING = 1 + ACTION_GOING_TO_BALL = 2 + ACTION_TRYING_TO_SCORE = 3 + ACTION_WAITING = 4 + ACTION_KICKING = 5 + ACTION_SEARCHING = 6 + ACTION_LOCALIZING = 7 + +@unique +class Penalty(IntEnum): + """Enum for the penalty of the robot. + Inferred from: https://github.com/RoboCup-Humanoid-TC/GameController/blob/master/src/data/values/Penalties.java + """ + + UNKNOWN = 255 + NONE = 0 + SUBSTITUTE = 14 + MANUAL = 15 + HL_BALL_MANIPULATION = 30 + HL_PHYSICAL_CONTACT = 31 + HL_PICKUP_OR_INCAPABLE = 34 + HL_SERVICE = 35 + + +@dataclass +class RobotInfo: # Inferred from the GameState struct + + penalty: Penalty + secs_till_unpenalized: int + number_of_warnings: int + number_of_yellow_cards: int + number_of_red_cards: int + goalkeeper: bool + + +@dataclass(frozen=True) +class StaticPlayer(StaticMatchObject): + """Static information about a player. + + :param id: Unique id of the player object + :type id: str + :param mass: Mass of the player in kg + :type mass: float + :param DOF: Degrees of freedom of the player + :type DOF: int + :param platform: Robot platform of the player + :type platform: str + :param mono_camera: Mono camera of the player + :type mono_camera: Optional[Camera] + :param stereo_camera_l: Left stereo camera of the player + :type stereo_camera_l: Optional[Camera] + :param stereo_camera_r: Right stereo camera of the player + :type stereo_camera_r: Optional[Camera] + """ + + DOF: int + platform: str + + mono_camera: Optional[Camera] = None + stereo_camera_l: Optional[Camera] = None + stereo_camera_r: Optional[Camera] = None + + +@dataclass +class Player(MatchObject, DataClassJsonMixin): + """Player is a MatchObject. + + :param id: Unique id of the player object + :type id: str + :param base_link: Base link frame of the player + :type base_link: Frame + :param l_sole: Left sole frame of the player + :type l_sole: Frame + :param r_sole: Right sole frame of the player + :type r_sole: Frame + :param l_gripper: Left gripper frame of the player + :type l_gripper: Frame + :param r_gripper: Right gripper frame of the player + :type r_gripper: Frame + :param camera_frame: Camera frame of the player + :type camera_frame: Optional[Frame] + :param l_camera_frame: Left camera frame of the player + :type l_camera_frame: Optional[Frame] + :param r_camera_frame: Right camera frame of the player + :type r_camera_frame: Optional[Frame] + :param state: Current state of the player, defaults to State.UNKNOWN_STATE + :type state: State, optional + :param role: Current role of the player, defaults to Role.ROLE_UNDEFINED + :type role: Role, optional + :param action: Current action of the player, defaults to Action.ACTION_UNDEFINED + :type action: Action, optional + :param robot_info: Robot info of the player, defaults to None + :type robot_info: Optional[RobotInfo], optional + """ + + base_link: Frame + l_sole: Frame + r_sole: Frame + l_gripper: Frame + r_gripper: Frame + + camera_frame: Optional[Frame] = None + l_camera_frame: Optional[Frame] = None + r_camera_frame: Optional[Frame] = None + + state: State = State.UNKNOWN_STATE + role: Role = Role.ROLE_UNDEFINED + action: Action = Action.ACTION_UNDEFINED + + robot_info: Optional[RobotInfo] = None + + def get_soles(self) -> Tuple[Frame, Frame]: + """Returns the left and right sole frames of the player. + + :return: Left and right sole frames of the player + :rtype: Tuple[Frame, Frame] + """ + return (self.l_sole, self.r_sole) + + def get_grippers(self) -> Tuple[Frame, Frame]: + """Returns the left and right gripper frames of the player. + + :return: Left and right gripper frames of the player + :rtype: Tuple[Frame, Frame] + """ + return (self.l_gripper, self.r_gripper) + + def get_stereo_camera_frames(self) -> Tuple[Optional[Frame], Optional[Frame]]: + """Returns the left and right camera frames of the player. + + :return: Left and right camera frames of the player + :rtype: Tuple[Optional[Frame], Optional[Frame]] + """ + return (self.l_camera_frame, self.r_camera_frame) diff --git a/controllers/referee/data_collection/match_info/pose.py b/controllers/referee/data_collection/match_info/pose.py new file mode 100644 index 00000000..5e521615 --- /dev/null +++ b/controllers/referee/data_collection/match_info/pose.py @@ -0,0 +1,90 @@ +from dataclasses import dataclass +from typing import Tuple + +import numpy as np +import transforms3d +from dataclasses_json import DataClassJsonMixin + + +@dataclass(frozen=True) +class Position(DataClassJsonMixin): + """Position of an object in 3D space. + + :param x: X coordinate of the position + :type x: float + :param y: Y coordinate of the position + :type y: float + :param z: Z coordinate of the position + :type z: float + """ + + x: float + y: float + z: float + + +@dataclass(frozen=True) +class Rotation(DataClassJsonMixin): + """Rotation of an object in 3D space as a quaternion. + + :param x: X component of the quaternion + :type x: float + :param y: Y component of the quaternion + :type y: float + :param z: Z component of the quaternion + :type z: float + :param w: W component of the quaternion + :type w: float + """ + + x: float + y: float + z: float + w: float + + def quaternion(self) -> Tuple[float, float, float, float]: + """Return the quaternion as a tuple. + + :return: Quaternion in the order [x, y, z, w] + :rtype: Tuple[float, float, float, float] + """ + return (self.x, self.y, self.z, self.w) + + def rpy(self) -> Tuple[float, float, float]: + """Convert rotation to euler angles. + + :return: Euler angles in the order [roll, pitch, yaw] + :rtype: Tuple[float, float, float] + """ + return transforms3d.euler.quat2euler((self.x, self.y, self.z, self.w)) + + +@dataclass(frozen=True) +class Pose(DataClassJsonMixin): + """Pose of an object in 3D space. + + :param position: Position of the object + :type position: Position + :param rotation: Rotation of the object + :type rotation: Rotation + """ + + position: Position + rotation: Rotation + + +def pose_from_affine(affine: np.ndarray) -> Pose: + """Convert a 4x4 or 16(x1) affine matrix to a Pose. + + :param affine: Affine matrix + :type affine: np.ndarray + :return: Pose + :rtype: Pose + """ + # Reshape 16x1 to 4x4 + if affine.shape == (16,): + affine = affine.reshape(4, 4) + + position = Position(affine[0, 3], affine[1, 3], affine[2, 3]) + rotation = Rotation(*transforms3d.quaternions.mat2quat(affine[:3, :3])) + return Pose(position, rotation) diff --git a/controllers/referee/data_collection/match_info/simulation.py b/controllers/referee/data_collection/match_info/simulation.py new file mode 100644 index 00000000..d5899065 --- /dev/null +++ b/controllers/referee/data_collection/match_info/simulation.py @@ -0,0 +1,21 @@ +from dataclasses import dataclass + + +# TODO: collection information about the match (docker hash, commit hash, etc.) + + +@dataclass(frozen=True) +class Simulation: + """Holds data about a match simulation. + + :param is_simulated: Whether the match is simulated + :type is_simulated: bool + :param basic_time_step: Basic time step of the simulation in ms + :type basic_time_step: int + :param data_collection_interval: Interval of steps when data is collected. Example: 8 means every 8th step is collected: current_step % data_collection_interval == 0 + :type data_collection_interval: int + """ + + is_simulated: bool + basic_time_step: int + data_collection_interval: int diff --git a/controllers/referee/data_collection/match_info/static_match_info.py b/controllers/referee/data_collection/match_info/static_match_info.py new file mode 100644 index 00000000..91c200cf --- /dev/null +++ b/controllers/referee/data_collection/match_info/static_match_info.py @@ -0,0 +1,64 @@ +from dataclasses import dataclass +from enum import Enum, IntEnum, unique + +from dataclasses_json import DataClassJsonMixin + +from .ball import StaticBall +from .field import Field +from .simulation import Simulation +from .team import StaticTeams + + +@unique +class MatchType(IntEnum): + """Match type enum.""" + + UNKNOWN = -1 + ROUNDROBIN = 0 + PLAYOFF = 1 + DROPIN = 2 + PENALTY = 10 # Penalty shootout as in referee + + +@unique +class LeagueSubType(str, Enum): # Inherit from str to make it JSON serializable + """League sub type enum.""" + + KID = "KID" + ADULT = "ADULT" + + +@dataclass(frozen=True) +class StaticMatchInfo(DataClassJsonMixin): + """Static information about a match. + + :param id: Match id + :type id: str + :param match_type: Type of this match (Normal, KnockOut, RoundRobin, DropIn) + :type match_type: MatchType + :param league_sub_type: Sub type of this match (Kid, Adult) + :type league_sub_type: LeagueSubType + :param simulation: Simulation data + :type simulation: Simulation + :param field: Field data + :type field: Field + :param ball: Ball data + :type ball: StaticBall + :param teams: Team data + :type teams: StaticTeams + :param kick_off_team: Id of the team that kicks off + :type kick_off_team: str + :param version: Version of the match_info package + :type version: str + """ + + id: str + match_type: MatchType + league_sub_type: LeagueSubType + simulation: Simulation + field: Field + ball: StaticBall + teams: StaticTeams + kick_off_team: str + + version: str = "0.0.1" diff --git a/controllers/referee/data_collection/match_info/step.py b/controllers/referee/data_collection/match_info/step.py new file mode 100644 index 00000000..2e4713ca --- /dev/null +++ b/controllers/referee/data_collection/match_info/step.py @@ -0,0 +1,106 @@ +from dataclasses import dataclass +from enum import IntEnum, unique +from typing import Optional + +from dataclasses_json import DataClassJsonMixin +from forceful_contact_matrix import ForcefulContactMatrix + +from .ball import Ball +from .team import Teams + + +@dataclass +class GameControlData: + """Holds data of game controller communication. + See here for more information: https://github.com/RoboCup-Humanoid-TC/GameController/wiki/GameControlData + + :param game_state: Game state + :type game_state: GameState + :param first_half: True if first half, False if second half + :type first_half: bool + :param kickoff_team: The team number of the next team to kick off or DROPBALL + :type kickoff_team: int + :param secondary_state: Secondary game state + :type secondary_state: SecondaryGameState + :param secondary_state_info_team: The team number of the team performing the secondary state (e.g. direct free kick) + :type secondary_state_info_team: int + :param secondary_state_info_sub_state: The sub state of the secondary state (0 for ready, 1 for freeze/ball repositioning by referee) + :type secondary_state_info_sub_state: int + :param drop_in_team: The team number of the team that caused last drop in + :type drop_in_team: int + :param drop_in_time: The number of seconds passed since the last drop in. -1 before first drop in + :type drop_in_time: int + :param secs_remaining: The number of seconds remaining in the half + :type secs_remaining: int + :param secondary_seconds_remaining: The number of seconds shown as secondary time (remaining ready, until free ball, etc) + :type secondary_seconds_remaining: int + """ + + @unique + class GameState(IntEnum): + """Enum for game states. + Inferred from the GameState struct + """ + + STATE_INITIAL = 0 + STATE_READY = 1 # Go to start position + STATE_SET = 2 # Keep ready + STATE_PLAYING = 3 # Start play + STATE_FINISHED = 4 # Game over + + @unique + class SecondaryGameState(IntEnum): + """Enum for secondary game states. + Inferred from the GameState struct + """ + + STATE_NORMAL = 0 + STATE_PENALTYSHOOT = 1 + STATE_OVERTIME = 2 + STATE_TIMEOUT = 3 + STATE_DIRECT_FREEKICK = 4 + STATE_INDIRECT_FREEKICK = 5 + STATE_PENALTYKICK = 6 + STATE_CORNERKICK = 7 + STATE_GOALKICK = 8 + STATE_THROWIN = 9 + STATE_DROPBALL = 128 + STATE_UNKNOWN = 255 + + game_state: GameState + first_half: bool + kickoff_team: int + secondary_state: SecondaryGameState + secondary_state_info_team: int + secondary_state_info_sub_state: int + drop_in_team: bool # TODO: GameState says this is bool, but docs say int + drop_in_time: int + seconds_remaining: int + secondary_seconds_remaining: int + + +@dataclass +class Step(DataClassJsonMixin): + """Holds data about a step. + + :param time: Time of step in simulation in seconds + :type time: float + :param delta_real_time: Time to calculate step in realtime in seconds, defaults to None + :type delta_real_time: Optional[float], optional + :param game_control_data: Game controller data, defaults to None + :type game_control_data: Optional[GameControlData], optional + :param ball: Ball data, defaults to None + :type ball: Optional[Ball], optional + :param teams: Team data, defaults to None + :type teams: Optional[Teams], optional + """ + + time: float + + delta_real_time: Optional[float] = None + + game_control_data: Optional[GameControlData] = None + + ball: Optional[Ball] = None + teams: Optional[Teams] = None + # collision_matrix: Optional[ForcefulContactMatrix] = None # TODO: Implement this diff --git a/controllers/referee/data_collection/match_info/team.py b/controllers/referee/data_collection/match_info/team.py new file mode 100644 index 00000000..5f93847b --- /dev/null +++ b/controllers/referee/data_collection/match_info/team.py @@ -0,0 +1,206 @@ +from dataclasses import dataclass +from enum import IntEnum, unique +from typing import Optional, Tuple + +from dataclasses_json import DataClassJsonMixin + +from .player import Player, StaticPlayer + + +@unique +class TeamColor(IntEnum): + """Enum for team colors. + Inferred from the GameState struct + """ + + BLUE = 0 + RED = 1 + YELLOW = 2 + BLACK = 3 + WHITE = 4 + GREEN = 5 + ORANGE = 6 + PURPLE = 7 + BROWN = 8 + GRAY = 9 + + +@dataclass(frozen=True) +class StaticTeam: + """Static information about a team. + + :param id: Team id + :type id: str + :param name: Team name + :type name: str + :param color: Team color + :type color: TeamColor + :param player1: First player + :type player1: StaticPlayer + :param player2: Second player + :type player2: StaticPlayer + :param player3: Third player + :type player3: StaticPlayer + :param player4: Fourth player + :type player4: StaticPlayer + """ + + id: str + name: str + color: TeamColor + + player1: StaticPlayer + player2: StaticPlayer + player3: StaticPlayer + player4: StaticPlayer + + +@dataclass(frozen=True) +class StaticTeams: + """Static information about the teams. + + :param team1: First team + :type team1: StaticTeam + :param team2: Second team + :type team2: StaticTeam + """ + + team1: StaticTeam + team2: StaticTeam + + def get_teams(self) -> Tuple[StaticTeam, StaticTeam]: + """Returns the teams. + + :return: Teams + :rtype: Tuple[StaticTeam, StaticTeam] + """ + return self.team1, self.team2 + + def get_team_by_id(self, id: str) -> StaticTeam: + """Returns the team with the given id. + + :param id: Id of the team + :type id: str + :raises ValueError: If no team with the given id exists + :return: Team with the given id + :rtype: StaticTeam + """ + for team in self.get_teams(): + if team.id == id: + return team + raise ValueError(f"Team with id {id} not found") + + def get_team_by_color(self, color: TeamColor) -> StaticTeam: + """Returns the team with the given color. + + :param color: Color of the team + :type color: TeamColor + :raises ValueError: If no team with the given color exists + :return: Team with the given color + :rtype: StaticTeam + """ + for team in self.get_teams(): + if team.color == color: + return team + raise ValueError(f"Team with color {color} not found") + + def red(self) -> StaticTeam: + """Returns the red team. + + :raises ValueError: If no red team exists + :return: Red team + :rtype: StaticTeam + """ + return self.get_team_by_color(TeamColor.RED) + + def blue(self) -> StaticTeam: + """Returns the blue team. + + :raises ValueError: If no blue team exists + :return: Blue team + :rtype: StaticTeam + """ + return self.get_team_by_color(TeamColor.BLUE) + + def get_team_by_name(self, name: str) -> StaticTeam: + """Returns the team with the given name. + + :param name: Name of the team + :type name: str + :raises ValueError: If no team with the given name exists + :return: Team with the given name + :rtype: StaticTeam + """ + for team in self.get_teams(): + if team.name == name: + return team + raise ValueError(f"Team with name {name} not found") + + +@dataclass +class Team(DataClassJsonMixin): + """Dynamic data about a team. + :param id: Team id + :type id: str + :param player1: First player, defaults to None + :type player1: Optional[Player], optional + :param player2: Second player, defaults to None + :type player2: Optional[Player], optional + :param player3: Third player, defaults to None + :type player3: Optional[Player], optional + :param player4: Fourth player, defaults to None + :type player4: Optional[Player], optional + :param score: Score, defaults to 0 + :type score: int, optional + :param penalty_shots: Penalty shots, defaults to 0 + :type penalty_shots: int, optional + :param single_shots: Single shots (bits represent penalty shot success), defaults to 0 + :type single_shots: int, optional + """ + + id: str + + player1: Optional[Player] = None + player2: Optional[Player] = None + player3: Optional[Player] = None + player4: Optional[Player] = None + + score: int = 0 + penalty_shots: int = 0 + single_shots: int = 0 # TODO: What is this? + + +@dataclass(frozen=True) +class Teams(DataClassJsonMixin): + """Holds both teams. + + :param team1: First team + :type team1: Team + :param team2: Second team + :type team2: Team + """ + + team1: Team + team2: Team + + def get_teams(self) -> Tuple[Team, Team]: + """Returns the teams. + + :return: Teams + :rtype: Tuple[Team, Team] + """ + return self.team1, self.team2 + + def get_team_by_id(self, id: str) -> Team: + """Returns the team with the given id. + + :param id: Id of the team + :type id: str + :raises ValueError: If no team with the given id exists + :return: Team with the given id + :rtype: Team + """ + for team in self.get_teams(): + if team.id == id: + return team + raise ValueError(f"Team with id {id} not found") diff --git a/controllers/referee/data_collection/post_processing/add_additional_robot_data.py b/controllers/referee/data_collection/post_processing/add_additional_robot_data.py new file mode 100755 index 00000000..b42995fa --- /dev/null +++ b/controllers/referee/data_collection/post_processing/add_additional_robot_data.py @@ -0,0 +1,53 @@ +#!/usr/bin/python3 + +from typing import Dict + +import json +import sys + + +def fill_in_additional_player_data(data_collection: Dict, additional_data: Dict): + """ + Fills in the additional player data to the data collection (in place) + + :param data_collection: Dict from the data collection json file + :type data_collection: Dict + :param additional_data: Dict from the additional data json file + :type additional_data: Dict + """ + # Iterate over teams and players in the data collection + for team in data_collection["teams"].values(): + for player_key in ["player1", "player2", "player3", "player4"]: + # Get the player from the team + player = team[player_key] + + if player is None: + continue + + # Get the player's platform to match the additional data + player_platform = player["platform"] + + # Get the additional data for the player + player_additional_data = additional_data[player_platform] + + # Add the additional data to the player + player.update(player_additional_data) + + +if __name__ == "__main__": + # Load the path to the additional data json file + with open(sys.argv[1], "r") as f: + additional_data = json.load(f) + + data_collection_path = sys.argv[2] + + # Load the data collection json file + with open(data_collection_path, "r") as f: + data_collection = json.load(f) + + # Fill in the additional data + fill_in_additional_player_data(data_collection, additional_data) + + # Save the modified data collection json file + with open(data_collection_path, "w") as f: + json.dump(data_collection, f, indent=4) diff --git a/controllers/referee/data_collection/post_processing/additional_robot_data.json b/controllers/referee/data_collection/post_processing/additional_robot_data.json new file mode 100644 index 00000000..c50f9a7c --- /dev/null +++ b/controllers/referee/data_collection/post_processing/additional_robot_data.json @@ -0,0 +1,60 @@ +{ + "BezRobocup": { + "mass": 4.78819, + "DOF": 18, + "mono_camera": { + "frame_id": "camera_frame", + "FPS": -1, + "FOV": 1.39626, + "pixel_count_x": 640, + "pixel_count_y": 480 + }, + "stereo_camera_l": null, + "stereo_camera_r": null + }, + "ChapeRobocup": { + "mass": 3.40484, + "DOF": 20, + "mono_camera": { + "frame_id": "camera_frame", + "FPS": -1, + "FOV": 1.0123, + "pixel_count_x": 640, + "pixel_count_y": 480 + }, + "stereo_camera_l": null, + "stereo_camera_r": null + }, + "NUgus": { + "mass": 7.33387, + "DOF": 20, + "mono_camera": null, + "stereo_camera_l": { + "frame_id": "l_camera_frame", + "FPS": -1, + "FOV": 1.5707, + "pixel_count_x": 640, + "pixel_count_y": 480 + }, + "stereo_camera_r": { + "frame_id": "r_camera_frame", + "FPS": -1, + "FOV": 1.5707, + "pixel_count_x": 640, + "pixel_count_y": 480 + } + }, + "WolfgangRobocup": { + "mass": 6.13661, + "DOF": 20, + "mono_camera": { + "frame_id": "camera_frame", + "FPS": -1, + "FOV": 1.04, + "pixel_count_x": 800, + "pixel_count_y": 600 + }, + "stereo_camera_l": null, + "stereo_camera_r": null + } +} diff --git a/controllers/referee/data_collection/post_processing/compile_proto.sh b/controllers/referee/data_collection/post_processing/compile_proto.sh new file mode 100755 index 00000000..4a850bb1 --- /dev/null +++ b/controllers/referee/data_collection/post_processing/compile_proto.sh @@ -0,0 +1,4 @@ +#! /bin/bash + +# protoc --python_out=. ./robocup.proto +protoc --python_out=. --mypy_out=. ./robocup_extension.proto diff --git a/controllers/referee/data_collection/post_processing/inspection.ipynb b/controllers/referee/data_collection/post_processing/inspection.ipynb new file mode 100644 index 00000000..9fda8d9f --- /dev/null +++ b/controllers/referee/data_collection/post_processing/inspection.ipynb @@ -0,0 +1,1168 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "path_feather = \"/home/jan/mafiasi-cloud/UHH/BA/data/pre-analysis/HLVS/2022_23/K-GD2/K-GD2-1/referee_data_collection_COMPLETE_2023-04-01T16-03-28.feather\"\n", + "path_pkl = \"/home/jan/mafiasi-cloud/UHH/BA/data/pre-analysis/HLVS/2022_23/K-GD2/K-GD2-1/referee_data_collection_COMPLETE_2023-04-01T16-03-28.pkl\"" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jan/.local/lib/python3.10/site-packages/requests/__init__.py:102: RequestsDependencyWarning: urllib3 (1.26.9) or chardet (5.1.0)/charset_normalizer (2.0.12) doesn't match a supported version!\n", + " warnings.warn(\"urllib3 ({}) or chardet ({})/charset_normalizer ({}) doesn't match a supported \"\n" + ] + } + ], + "source": [ + "from mplsoccer import Pitch\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import seaborn.objects as so" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Load data\n", + "data_feater = pd.read_feather(path_feather)\n", + "data_pickle = pd.read_pickle(path_pkl)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pitch = Pitch(pitch_color='grass', line_color='white', stripe=True)\n", + "fig, ax = pitch.draw()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
timedelta_real_timegame_control_data.game_stategame_control_data.first_halfgame_control_data.kickoff_teamgame_control_data.secondary_stategame_control_data.secondary_state_info_teamgame_control_data.secondary_state_info_sub_stategame_control_data.drop_in_teamgame_control_data.drop_in_time...teams.team2.player4.actionteams.team2.player4.robot_info.penaltyteams.team2.player4.robot_info.secs_till_unpenalizedteams.team2.player4.robot_info.number_of_warningsteams.team2.player4.robot_info.number_of_yellow_cardsteams.team2.player4.robot_info.number_of_red_cardsteams.team2.player4.robot_info.goalkeeperteams.team2.scoreteams.team2.penalty_shotsteams.team2.single_shots
00.0560.0704350True7000False65535...0140000False000
10.1200.0613080True7000False65535...0140000False000
20.1840.0575720True7000False65535...0140000False000
30.2480.0600820True7000False65535...0140000False000
40.3120.0566150True7000False65535...0140000False000
..................................................................
255391634.5520.0194913False7000False65535...0140000False200
255401634.6160.0224343False7000False65535...0140000False200
255411634.6800.0195603False7000False65535...0140000False200
255421634.7440.0201223False7000False65535...0140000False200
255431634.8080.8352203False7000False65535...0140000False200
\n", + "

25544 rows × 485 columns

\n", + "
" + ], + "text/plain": [ + " time delta_real_time game_control_data.game_state \n", + "0 0.056 0.070435 0 \\\n", + "1 0.120 0.061308 0 \n", + "2 0.184 0.057572 0 \n", + "3 0.248 0.060082 0 \n", + "4 0.312 0.056615 0 \n", + "... ... ... ... \n", + "25539 1634.552 0.019491 3 \n", + "25540 1634.616 0.022434 3 \n", + "25541 1634.680 0.019560 3 \n", + "25542 1634.744 0.020122 3 \n", + "25543 1634.808 0.835220 3 \n", + "\n", + " game_control_data.first_half game_control_data.kickoff_team \n", + "0 True 7 \\\n", + "1 True 7 \n", + "2 True 7 \n", + "3 True 7 \n", + "4 True 7 \n", + "... ... ... \n", + "25539 False 7 \n", + "25540 False 7 \n", + "25541 False 7 \n", + "25542 False 7 \n", + "25543 False 7 \n", + "\n", + " game_control_data.secondary_state \n", + "0 0 \\\n", + "1 0 \n", + "2 0 \n", + "3 0 \n", + "4 0 \n", + "... ... \n", + "25539 0 \n", + "25540 0 \n", + "25541 0 \n", + "25542 0 \n", + "25543 0 \n", + "\n", + " game_control_data.secondary_state_info_team \n", + "0 0 \\\n", + "1 0 \n", + "2 0 \n", + "3 0 \n", + "4 0 \n", + "... ... \n", + "25539 0 \n", + "25540 0 \n", + "25541 0 \n", + "25542 0 \n", + "25543 0 \n", + "\n", + " game_control_data.secondary_state_info_sub_state \n", + "0 0 \\\n", + "1 0 \n", + "2 0 \n", + "3 0 \n", + "4 0 \n", + "... ... \n", + "25539 0 \n", + "25540 0 \n", + "25541 0 \n", + "25542 0 \n", + "25543 0 \n", + "\n", + " game_control_data.drop_in_team game_control_data.drop_in_time ... \n", + "0 False 65535 ... \\\n", + "1 False 65535 ... \n", + "2 False 65535 ... \n", + "3 False 65535 ... \n", + "4 False 65535 ... \n", + "... ... ... ... \n", + "25539 False 65535 ... \n", + "25540 False 65535 ... \n", + "25541 False 65535 ... \n", + "25542 False 65535 ... \n", + "25543 False 65535 ... \n", + "\n", + " teams.team2.player4.action teams.team2.player4.robot_info.penalty \n", + "0 0 14 \\\n", + "1 0 14 \n", + "2 0 14 \n", + "3 0 14 \n", + "4 0 14 \n", + "... ... ... \n", + "25539 0 14 \n", + "25540 0 14 \n", + "25541 0 14 \n", + "25542 0 14 \n", + "25543 0 14 \n", + "\n", + " teams.team2.player4.robot_info.secs_till_unpenalized \n", + "0 0 \\\n", + "1 0 \n", + "2 0 \n", + "3 0 \n", + "4 0 \n", + "... ... \n", + "25539 0 \n", + "25540 0 \n", + "25541 0 \n", + "25542 0 \n", + "25543 0 \n", + "\n", + " teams.team2.player4.robot_info.number_of_warnings \n", + "0 0 \\\n", + "1 0 \n", + "2 0 \n", + "3 0 \n", + "4 0 \n", + "... ... \n", + "25539 0 \n", + "25540 0 \n", + "25541 0 \n", + "25542 0 \n", + "25543 0 \n", + "\n", + " teams.team2.player4.robot_info.number_of_yellow_cards \n", + "0 0 \\\n", + "1 0 \n", + "2 0 \n", + "3 0 \n", + "4 0 \n", + "... ... \n", + "25539 0 \n", + "25540 0 \n", + "25541 0 \n", + "25542 0 \n", + "25543 0 \n", + "\n", + " teams.team2.player4.robot_info.number_of_red_cards \n", + "0 0 \\\n", + "1 0 \n", + "2 0 \n", + "3 0 \n", + "4 0 \n", + "... ... \n", + "25539 0 \n", + "25540 0 \n", + "25541 0 \n", + "25542 0 \n", + "25543 0 \n", + "\n", + " teams.team2.player4.robot_info.goalkeeper teams.team2.score \n", + "0 False 0 \\\n", + "1 False 0 \n", + "2 False 0 \n", + "3 False 0 \n", + "4 False 0 \n", + "... ... ... \n", + "25539 False 2 \n", + "25540 False 2 \n", + "25541 False 2 \n", + "25542 False 2 \n", + "25543 False 2 \n", + "\n", + " teams.team2.penalty_shots teams.team2.single_shots \n", + "0 0 0 \n", + "1 0 0 \n", + "2 0 0 \n", + "3 0 0 \n", + "4 0 0 \n", + "... ... ... \n", + "25539 0 0 \n", + "25540 0 0 \n", + "25541 0 0 \n", + "25542 0 0 \n", + "25543 0 0 \n", + "\n", + "[25544 rows x 485 columns]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_feater" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "time\n", + "delta_real_time\n", + "game_control_data.game_state\n", + "game_control_data.first_half\n", + "game_control_data.kickoff_team\n", + "game_control_data.secondary_state\n", + "game_control_data.secondary_state_info_team\n", + "game_control_data.secondary_state_info_sub_state\n", + "game_control_data.drop_in_team\n", + "game_control_data.drop_in_time\n", + "game_control_data.seconds_remaining\n", + "game_control_data.secondary_seconds_remaining\n", + "ball.id\n", + "ball.frame.id\n", + "ball.frame.pose.position.x\n", + "ball.frame.pose.position.y\n", + "ball.frame.pose.position.z\n", + "ball.frame.pose.rotation.x\n", + "ball.frame.pose.rotation.y\n", + "ball.frame.pose.rotation.z\n", + "ball.frame.pose.rotation.w\n", + "teams.team1.id\n", + "teams.team1.player1.id\n", + "teams.team1.player1.base_link.position.x\n", + "teams.team1.player1.base_link.position.y\n", + "teams.team1.player1.base_link.position.z\n", + "teams.team1.player1.base_link.rotation.x\n", + "teams.team1.player1.base_link.rotation.y\n", + "teams.team1.player1.base_link.rotation.z\n", + "teams.team1.player1.base_link.rotation.w\n", + "teams.team1.player1.l_sole.position.x\n", + "teams.team1.player1.l_sole.position.y\n", + "teams.team1.player1.l_sole.position.z\n", + "teams.team1.player1.l_sole.rotation.x\n", + "teams.team1.player1.l_sole.rotation.y\n", + "teams.team1.player1.l_sole.rotation.z\n", + "teams.team1.player1.l_sole.rotation.w\n", + "teams.team1.player1.r_sole.position.x\n", + "teams.team1.player1.r_sole.position.y\n", + "teams.team1.player1.r_sole.position.z\n", + "teams.team1.player1.r_sole.rotation.x\n", + "teams.team1.player1.r_sole.rotation.y\n", + "teams.team1.player1.r_sole.rotation.z\n", + "teams.team1.player1.r_sole.rotation.w\n", + "teams.team1.player1.l_gripper.position.x\n", + "teams.team1.player1.l_gripper.position.y\n", + "teams.team1.player1.l_gripper.position.z\n", + "teams.team1.player1.l_gripper.rotation.x\n", + "teams.team1.player1.l_gripper.rotation.y\n", + "teams.team1.player1.l_gripper.rotation.z\n", + "teams.team1.player1.l_gripper.rotation.w\n", + "teams.team1.player1.r_gripper.position.x\n", + "teams.team1.player1.r_gripper.position.y\n", + "teams.team1.player1.r_gripper.position.z\n", + "teams.team1.player1.r_gripper.rotation.x\n", + "teams.team1.player1.r_gripper.rotation.y\n", + "teams.team1.player1.r_gripper.rotation.z\n", + "teams.team1.player1.r_gripper.rotation.w\n", + "teams.team1.player1.camera_frame\n", + "teams.team1.player1.l_camera_frame.position.x\n", + "teams.team1.player1.l_camera_frame.position.y\n", + "teams.team1.player1.l_camera_frame.position.z\n", + "teams.team1.player1.l_camera_frame.rotation.x\n", + "teams.team1.player1.l_camera_frame.rotation.y\n", + "teams.team1.player1.l_camera_frame.rotation.z\n", + "teams.team1.player1.l_camera_frame.rotation.w\n", + "teams.team1.player1.r_camera_frame.position.x\n", + "teams.team1.player1.r_camera_frame.position.y\n", + "teams.team1.player1.r_camera_frame.position.z\n", + "teams.team1.player1.r_camera_frame.rotation.x\n", + "teams.team1.player1.r_camera_frame.rotation.y\n", + "teams.team1.player1.r_camera_frame.rotation.z\n", + "teams.team1.player1.r_camera_frame.rotation.w\n", + "teams.team1.player1.state\n", + "teams.team1.player1.role\n", + "teams.team1.player1.action\n", + "teams.team1.player1.robot_info.penalty\n", + "teams.team1.player1.robot_info.secs_till_unpenalized\n", + "teams.team1.player1.robot_info.number_of_warnings\n", + "teams.team1.player1.robot_info.number_of_yellow_cards\n", + "teams.team1.player1.robot_info.number_of_red_cards\n", + "teams.team1.player1.robot_info.goalkeeper\n", + "teams.team1.player2.id\n", + "teams.team1.player2.base_link.position.x\n", + "teams.team1.player2.base_link.position.y\n", + "teams.team1.player2.base_link.position.z\n", + "teams.team1.player2.base_link.rotation.x\n", + "teams.team1.player2.base_link.rotation.y\n", + "teams.team1.player2.base_link.rotation.z\n", + "teams.team1.player2.base_link.rotation.w\n", + "teams.team1.player2.l_sole.position.x\n", + "teams.team1.player2.l_sole.position.y\n", + "teams.team1.player2.l_sole.position.z\n", + "teams.team1.player2.l_sole.rotation.x\n", + "teams.team1.player2.l_sole.rotation.y\n", + "teams.team1.player2.l_sole.rotation.z\n", + "teams.team1.player2.l_sole.rotation.w\n", + "teams.team1.player2.r_sole.position.x\n", + "teams.team1.player2.r_sole.position.y\n", + "teams.team1.player2.r_sole.position.z\n", + "teams.team1.player2.r_sole.rotation.x\n", + "teams.team1.player2.r_sole.rotation.y\n", + "teams.team1.player2.r_sole.rotation.z\n", + "teams.team1.player2.r_sole.rotation.w\n", + "teams.team1.player2.l_gripper.position.x\n", + "teams.team1.player2.l_gripper.position.y\n", + "teams.team1.player2.l_gripper.position.z\n", + "teams.team1.player2.l_gripper.rotation.x\n", + "teams.team1.player2.l_gripper.rotation.y\n", + "teams.team1.player2.l_gripper.rotation.z\n", + "teams.team1.player2.l_gripper.rotation.w\n", + "teams.team1.player2.r_gripper.position.x\n", + "teams.team1.player2.r_gripper.position.y\n", + "teams.team1.player2.r_gripper.position.z\n", + "teams.team1.player2.r_gripper.rotation.x\n", + "teams.team1.player2.r_gripper.rotation.y\n", + "teams.team1.player2.r_gripper.rotation.z\n", + "teams.team1.player2.r_gripper.rotation.w\n", + "teams.team1.player2.camera_frame\n", + "teams.team1.player2.l_camera_frame.position.x\n", + "teams.team1.player2.l_camera_frame.position.y\n", + "teams.team1.player2.l_camera_frame.position.z\n", + "teams.team1.player2.l_camera_frame.rotation.x\n", + "teams.team1.player2.l_camera_frame.rotation.y\n", + "teams.team1.player2.l_camera_frame.rotation.z\n", + "teams.team1.player2.l_camera_frame.rotation.w\n", + "teams.team1.player2.r_camera_frame.position.x\n", + "teams.team1.player2.r_camera_frame.position.y\n", + "teams.team1.player2.r_camera_frame.position.z\n", + "teams.team1.player2.r_camera_frame.rotation.x\n", + "teams.team1.player2.r_camera_frame.rotation.y\n", + "teams.team1.player2.r_camera_frame.rotation.z\n", + "teams.team1.player2.r_camera_frame.rotation.w\n", + "teams.team1.player2.state\n", + "teams.team1.player2.role\n", + "teams.team1.player2.action\n", + "teams.team1.player2.robot_info.penalty\n", + "teams.team1.player2.robot_info.secs_till_unpenalized\n", + "teams.team1.player2.robot_info.number_of_warnings\n", + "teams.team1.player2.robot_info.number_of_yellow_cards\n", + "teams.team1.player2.robot_info.number_of_red_cards\n", + "teams.team1.player2.robot_info.goalkeeper\n", + "teams.team1.player3.id\n", + "teams.team1.player3.base_link.position.x\n", + "teams.team1.player3.base_link.position.y\n", + "teams.team1.player3.base_link.position.z\n", + "teams.team1.player3.base_link.rotation.x\n", + "teams.team1.player3.base_link.rotation.y\n", + "teams.team1.player3.base_link.rotation.z\n", + "teams.team1.player3.base_link.rotation.w\n", + "teams.team1.player3.l_sole.position.x\n", + "teams.team1.player3.l_sole.position.y\n", + "teams.team1.player3.l_sole.position.z\n", + "teams.team1.player3.l_sole.rotation.x\n", + "teams.team1.player3.l_sole.rotation.y\n", + "teams.team1.player3.l_sole.rotation.z\n", + "teams.team1.player3.l_sole.rotation.w\n", + "teams.team1.player3.r_sole.position.x\n", + "teams.team1.player3.r_sole.position.y\n", + "teams.team1.player3.r_sole.position.z\n", + "teams.team1.player3.r_sole.rotation.x\n", + "teams.team1.player3.r_sole.rotation.y\n", + "teams.team1.player3.r_sole.rotation.z\n", + "teams.team1.player3.r_sole.rotation.w\n", + "teams.team1.player3.l_gripper.position.x\n", + "teams.team1.player3.l_gripper.position.y\n", + "teams.team1.player3.l_gripper.position.z\n", + "teams.team1.player3.l_gripper.rotation.x\n", + "teams.team1.player3.l_gripper.rotation.y\n", + "teams.team1.player3.l_gripper.rotation.z\n", + "teams.team1.player3.l_gripper.rotation.w\n", + "teams.team1.player3.r_gripper.position.x\n", + "teams.team1.player3.r_gripper.position.y\n", + "teams.team1.player3.r_gripper.position.z\n", + "teams.team1.player3.r_gripper.rotation.x\n", + "teams.team1.player3.r_gripper.rotation.y\n", + "teams.team1.player3.r_gripper.rotation.z\n", + "teams.team1.player3.r_gripper.rotation.w\n", + "teams.team1.player3.camera_frame\n", + "teams.team1.player3.l_camera_frame.position.x\n", + "teams.team1.player3.l_camera_frame.position.y\n", + "teams.team1.player3.l_camera_frame.position.z\n", + "teams.team1.player3.l_camera_frame.rotation.x\n", + "teams.team1.player3.l_camera_frame.rotation.y\n", + "teams.team1.player3.l_camera_frame.rotation.z\n", + "teams.team1.player3.l_camera_frame.rotation.w\n", + "teams.team1.player3.r_camera_frame.position.x\n", + "teams.team1.player3.r_camera_frame.position.y\n", + "teams.team1.player3.r_camera_frame.position.z\n", + "teams.team1.player3.r_camera_frame.rotation.x\n", + "teams.team1.player3.r_camera_frame.rotation.y\n", + "teams.team1.player3.r_camera_frame.rotation.z\n", + "teams.team1.player3.r_camera_frame.rotation.w\n", + "teams.team1.player3.state\n", + "teams.team1.player3.role\n", + "teams.team1.player3.action\n", + "teams.team1.player3.robot_info.penalty\n", + "teams.team1.player3.robot_info.secs_till_unpenalized\n", + "teams.team1.player3.robot_info.number_of_warnings\n", + "teams.team1.player3.robot_info.number_of_yellow_cards\n", + "teams.team1.player3.robot_info.number_of_red_cards\n", + "teams.team1.player3.robot_info.goalkeeper\n", + "teams.team1.player4.id\n", + "teams.team1.player4.base_link.position.x\n", + "teams.team1.player4.base_link.position.y\n", + "teams.team1.player4.base_link.position.z\n", + "teams.team1.player4.base_link.rotation.x\n", + "teams.team1.player4.base_link.rotation.y\n", + "teams.team1.player4.base_link.rotation.z\n", + "teams.team1.player4.base_link.rotation.w\n", + "teams.team1.player4.l_sole.position.x\n", + "teams.team1.player4.l_sole.position.y\n", + "teams.team1.player4.l_sole.position.z\n", + "teams.team1.player4.l_sole.rotation.x\n", + "teams.team1.player4.l_sole.rotation.y\n", + "teams.team1.player4.l_sole.rotation.z\n", + "teams.team1.player4.l_sole.rotation.w\n", + "teams.team1.player4.r_sole.position.x\n", + "teams.team1.player4.r_sole.position.y\n", + "teams.team1.player4.r_sole.position.z\n", + "teams.team1.player4.r_sole.rotation.x\n", + "teams.team1.player4.r_sole.rotation.y\n", + "teams.team1.player4.r_sole.rotation.z\n", + "teams.team1.player4.r_sole.rotation.w\n", + "teams.team1.player4.l_gripper.position.x\n", + "teams.team1.player4.l_gripper.position.y\n", + "teams.team1.player4.l_gripper.position.z\n", + "teams.team1.player4.l_gripper.rotation.x\n", + "teams.team1.player4.l_gripper.rotation.y\n", + "teams.team1.player4.l_gripper.rotation.z\n", + "teams.team1.player4.l_gripper.rotation.w\n", + "teams.team1.player4.r_gripper.position.x\n", + "teams.team1.player4.r_gripper.position.y\n", + "teams.team1.player4.r_gripper.position.z\n", + "teams.team1.player4.r_gripper.rotation.x\n", + "teams.team1.player4.r_gripper.rotation.y\n", + "teams.team1.player4.r_gripper.rotation.z\n", + "teams.team1.player4.r_gripper.rotation.w\n", + "teams.team1.player4.camera_frame\n", + "teams.team1.player4.l_camera_frame.position.x\n", + "teams.team1.player4.l_camera_frame.position.y\n", + "teams.team1.player4.l_camera_frame.position.z\n", + "teams.team1.player4.l_camera_frame.rotation.x\n", + "teams.team1.player4.l_camera_frame.rotation.y\n", + "teams.team1.player4.l_camera_frame.rotation.z\n", + "teams.team1.player4.l_camera_frame.rotation.w\n", + "teams.team1.player4.r_camera_frame.position.x\n", + "teams.team1.player4.r_camera_frame.position.y\n", + "teams.team1.player4.r_camera_frame.position.z\n", + "teams.team1.player4.r_camera_frame.rotation.x\n", + "teams.team1.player4.r_camera_frame.rotation.y\n", + "teams.team1.player4.r_camera_frame.rotation.z\n", + "teams.team1.player4.r_camera_frame.rotation.w\n", + "teams.team1.player4.state\n", + "teams.team1.player4.role\n", + "teams.team1.player4.action\n", + "teams.team1.player4.robot_info.penalty\n", + "teams.team1.player4.robot_info.secs_till_unpenalized\n", + "teams.team1.player4.robot_info.number_of_warnings\n", + "teams.team1.player4.robot_info.number_of_yellow_cards\n", + "teams.team1.player4.robot_info.number_of_red_cards\n", + "teams.team1.player4.robot_info.goalkeeper\n", + "teams.team1.score\n", + "teams.team1.penalty_shots\n", + "teams.team1.single_shots\n", + "teams.team2.id\n", + "teams.team2.player1.id\n", + "teams.team2.player1.base_link.position.x\n", + "teams.team2.player1.base_link.position.y\n", + "teams.team2.player1.base_link.position.z\n", + "teams.team2.player1.base_link.rotation.x\n", + "teams.team2.player1.base_link.rotation.y\n", + "teams.team2.player1.base_link.rotation.z\n", + "teams.team2.player1.base_link.rotation.w\n", + "teams.team2.player1.l_sole.position.x\n", + "teams.team2.player1.l_sole.position.y\n", + "teams.team2.player1.l_sole.position.z\n", + "teams.team2.player1.l_sole.rotation.x\n", + "teams.team2.player1.l_sole.rotation.y\n", + "teams.team2.player1.l_sole.rotation.z\n", + "teams.team2.player1.l_sole.rotation.w\n", + "teams.team2.player1.r_sole.position.x\n", + "teams.team2.player1.r_sole.position.y\n", + "teams.team2.player1.r_sole.position.z\n", + "teams.team2.player1.r_sole.rotation.x\n", + "teams.team2.player1.r_sole.rotation.y\n", + "teams.team2.player1.r_sole.rotation.z\n", + "teams.team2.player1.r_sole.rotation.w\n", + "teams.team2.player1.l_gripper.position.x\n", + "teams.team2.player1.l_gripper.position.y\n", + "teams.team2.player1.l_gripper.position.z\n", + "teams.team2.player1.l_gripper.rotation.x\n", + "teams.team2.player1.l_gripper.rotation.y\n", + "teams.team2.player1.l_gripper.rotation.z\n", + "teams.team2.player1.l_gripper.rotation.w\n", + "teams.team2.player1.r_gripper.position.x\n", + "teams.team2.player1.r_gripper.position.y\n", + "teams.team2.player1.r_gripper.position.z\n", + "teams.team2.player1.r_gripper.rotation.x\n", + "teams.team2.player1.r_gripper.rotation.y\n", + "teams.team2.player1.r_gripper.rotation.z\n", + "teams.team2.player1.r_gripper.rotation.w\n", + "teams.team2.player1.camera_frame.position.x\n", + "teams.team2.player1.camera_frame.position.y\n", + "teams.team2.player1.camera_frame.position.z\n", + "teams.team2.player1.camera_frame.rotation.x\n", + "teams.team2.player1.camera_frame.rotation.y\n", + "teams.team2.player1.camera_frame.rotation.z\n", + "teams.team2.player1.camera_frame.rotation.w\n", + "teams.team2.player1.l_camera_frame\n", + "teams.team2.player1.r_camera_frame\n", + "teams.team2.player1.state\n", + "teams.team2.player1.role\n", + "teams.team2.player1.action\n", + "teams.team2.player1.robot_info.penalty\n", + "teams.team2.player1.robot_info.secs_till_unpenalized\n", + "teams.team2.player1.robot_info.number_of_warnings\n", + "teams.team2.player1.robot_info.number_of_yellow_cards\n", + "teams.team2.player1.robot_info.number_of_red_cards\n", + "teams.team2.player1.robot_info.goalkeeper\n", + "teams.team2.player2.id\n", + "teams.team2.player2.base_link.position.x\n", + "teams.team2.player2.base_link.position.y\n", + "teams.team2.player2.base_link.position.z\n", + "teams.team2.player2.base_link.rotation.x\n", + "teams.team2.player2.base_link.rotation.y\n", + "teams.team2.player2.base_link.rotation.z\n", + "teams.team2.player2.base_link.rotation.w\n", + "teams.team2.player2.l_sole.position.x\n", + "teams.team2.player2.l_sole.position.y\n", + "teams.team2.player2.l_sole.position.z\n", + "teams.team2.player2.l_sole.rotation.x\n", + "teams.team2.player2.l_sole.rotation.y\n", + "teams.team2.player2.l_sole.rotation.z\n", + "teams.team2.player2.l_sole.rotation.w\n", + "teams.team2.player2.r_sole.position.x\n", + "teams.team2.player2.r_sole.position.y\n", + "teams.team2.player2.r_sole.position.z\n", + "teams.team2.player2.r_sole.rotation.x\n", + "teams.team2.player2.r_sole.rotation.y\n", + "teams.team2.player2.r_sole.rotation.z\n", + "teams.team2.player2.r_sole.rotation.w\n", + "teams.team2.player2.l_gripper.position.x\n", + "teams.team2.player2.l_gripper.position.y\n", + "teams.team2.player2.l_gripper.position.z\n", + "teams.team2.player2.l_gripper.rotation.x\n", + "teams.team2.player2.l_gripper.rotation.y\n", + "teams.team2.player2.l_gripper.rotation.z\n", + "teams.team2.player2.l_gripper.rotation.w\n", + "teams.team2.player2.r_gripper.position.x\n", + "teams.team2.player2.r_gripper.position.y\n", + "teams.team2.player2.r_gripper.position.z\n", + "teams.team2.player2.r_gripper.rotation.x\n", + "teams.team2.player2.r_gripper.rotation.y\n", + "teams.team2.player2.r_gripper.rotation.z\n", + "teams.team2.player2.r_gripper.rotation.w\n", + "teams.team2.player2.camera_frame.position.x\n", + "teams.team2.player2.camera_frame.position.y\n", + "teams.team2.player2.camera_frame.position.z\n", + "teams.team2.player2.camera_frame.rotation.x\n", + "teams.team2.player2.camera_frame.rotation.y\n", + "teams.team2.player2.camera_frame.rotation.z\n", + "teams.team2.player2.camera_frame.rotation.w\n", + "teams.team2.player2.l_camera_frame\n", + "teams.team2.player2.r_camera_frame\n", + "teams.team2.player2.state\n", + "teams.team2.player2.role\n", + "teams.team2.player2.action\n", + "teams.team2.player2.robot_info.penalty\n", + "teams.team2.player2.robot_info.secs_till_unpenalized\n", + "teams.team2.player2.robot_info.number_of_warnings\n", + "teams.team2.player2.robot_info.number_of_yellow_cards\n", + "teams.team2.player2.robot_info.number_of_red_cards\n", + "teams.team2.player2.robot_info.goalkeeper\n", + "teams.team2.player3.id\n", + "teams.team2.player3.base_link.position.x\n", + "teams.team2.player3.base_link.position.y\n", + "teams.team2.player3.base_link.position.z\n", + "teams.team2.player3.base_link.rotation.x\n", + "teams.team2.player3.base_link.rotation.y\n", + "teams.team2.player3.base_link.rotation.z\n", + "teams.team2.player3.base_link.rotation.w\n", + "teams.team2.player3.l_sole.position.x\n", + "teams.team2.player3.l_sole.position.y\n", + "teams.team2.player3.l_sole.position.z\n", + "teams.team2.player3.l_sole.rotation.x\n", + "teams.team2.player3.l_sole.rotation.y\n", + "teams.team2.player3.l_sole.rotation.z\n", + "teams.team2.player3.l_sole.rotation.w\n", + "teams.team2.player3.r_sole.position.x\n", + "teams.team2.player3.r_sole.position.y\n", + "teams.team2.player3.r_sole.position.z\n", + "teams.team2.player3.r_sole.rotation.x\n", + "teams.team2.player3.r_sole.rotation.y\n", + "teams.team2.player3.r_sole.rotation.z\n", + "teams.team2.player3.r_sole.rotation.w\n", + "teams.team2.player3.l_gripper.position.x\n", + "teams.team2.player3.l_gripper.position.y\n", + "teams.team2.player3.l_gripper.position.z\n", + "teams.team2.player3.l_gripper.rotation.x\n", + "teams.team2.player3.l_gripper.rotation.y\n", + "teams.team2.player3.l_gripper.rotation.z\n", + "teams.team2.player3.l_gripper.rotation.w\n", + "teams.team2.player3.r_gripper.position.x\n", + "teams.team2.player3.r_gripper.position.y\n", + "teams.team2.player3.r_gripper.position.z\n", + "teams.team2.player3.r_gripper.rotation.x\n", + "teams.team2.player3.r_gripper.rotation.y\n", + "teams.team2.player3.r_gripper.rotation.z\n", + "teams.team2.player3.r_gripper.rotation.w\n", + "teams.team2.player3.camera_frame.position.x\n", + "teams.team2.player3.camera_frame.position.y\n", + "teams.team2.player3.camera_frame.position.z\n", + "teams.team2.player3.camera_frame.rotation.x\n", + "teams.team2.player3.camera_frame.rotation.y\n", + "teams.team2.player3.camera_frame.rotation.z\n", + "teams.team2.player3.camera_frame.rotation.w\n", + "teams.team2.player3.l_camera_frame\n", + "teams.team2.player3.r_camera_frame\n", + "teams.team2.player3.state\n", + "teams.team2.player3.role\n", + "teams.team2.player3.action\n", + "teams.team2.player3.robot_info.penalty\n", + "teams.team2.player3.robot_info.secs_till_unpenalized\n", + "teams.team2.player3.robot_info.number_of_warnings\n", + "teams.team2.player3.robot_info.number_of_yellow_cards\n", + "teams.team2.player3.robot_info.number_of_red_cards\n", + "teams.team2.player3.robot_info.goalkeeper\n", + "teams.team2.player4.id\n", + "teams.team2.player4.base_link.position.x\n", + "teams.team2.player4.base_link.position.y\n", + "teams.team2.player4.base_link.position.z\n", + "teams.team2.player4.base_link.rotation.x\n", + "teams.team2.player4.base_link.rotation.y\n", + "teams.team2.player4.base_link.rotation.z\n", + "teams.team2.player4.base_link.rotation.w\n", + "teams.team2.player4.l_sole.position.x\n", + "teams.team2.player4.l_sole.position.y\n", + "teams.team2.player4.l_sole.position.z\n", + "teams.team2.player4.l_sole.rotation.x\n", + "teams.team2.player4.l_sole.rotation.y\n", + "teams.team2.player4.l_sole.rotation.z\n", + "teams.team2.player4.l_sole.rotation.w\n", + "teams.team2.player4.r_sole.position.x\n", + "teams.team2.player4.r_sole.position.y\n", + "teams.team2.player4.r_sole.position.z\n", + "teams.team2.player4.r_sole.rotation.x\n", + "teams.team2.player4.r_sole.rotation.y\n", + "teams.team2.player4.r_sole.rotation.z\n", + "teams.team2.player4.r_sole.rotation.w\n", + "teams.team2.player4.l_gripper.position.x\n", + "teams.team2.player4.l_gripper.position.y\n", + "teams.team2.player4.l_gripper.position.z\n", + "teams.team2.player4.l_gripper.rotation.x\n", + "teams.team2.player4.l_gripper.rotation.y\n", + "teams.team2.player4.l_gripper.rotation.z\n", + "teams.team2.player4.l_gripper.rotation.w\n", + "teams.team2.player4.r_gripper.position.x\n", + "teams.team2.player4.r_gripper.position.y\n", + "teams.team2.player4.r_gripper.position.z\n", + "teams.team2.player4.r_gripper.rotation.x\n", + "teams.team2.player4.r_gripper.rotation.y\n", + "teams.team2.player4.r_gripper.rotation.z\n", + "teams.team2.player4.r_gripper.rotation.w\n", + "teams.team2.player4.camera_frame.position.x\n", + "teams.team2.player4.camera_frame.position.y\n", + "teams.team2.player4.camera_frame.position.z\n", + "teams.team2.player4.camera_frame.rotation.x\n", + "teams.team2.player4.camera_frame.rotation.y\n", + "teams.team2.player4.camera_frame.rotation.z\n", + "teams.team2.player4.camera_frame.rotation.w\n", + "teams.team2.player4.l_camera_frame\n", + "teams.team2.player4.r_camera_frame\n", + "teams.team2.player4.state\n", + "teams.team2.player4.role\n", + "teams.team2.player4.action\n", + "teams.team2.player4.robot_info.penalty\n", + "teams.team2.player4.robot_info.secs_till_unpenalized\n", + "teams.team2.player4.robot_info.number_of_warnings\n", + "teams.team2.player4.robot_info.number_of_yellow_cards\n", + "teams.team2.player4.robot_info.number_of_red_cards\n", + "teams.team2.player4.robot_info.goalkeeper\n", + "teams.team2.score\n", + "teams.team2.penalty_shots\n", + "teams.team2.single_shots\n" + ] + } + ], + "source": [ + "for s in data_feater.columns:\n", + " print(s)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Filter out ball positions at 100, 100\n", + "filtered_df = data_feater.loc[(data_feater['ball.frame.pose.position.x'] >= -10) & (data_feater['ball.frame.pose.position.x'] <= 10)].copy()\n", + "sns.scatterplot(filtered_df, x=\"ball.frame.pose.position.x\", y=\"ball.frame.pose.position.y\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjUAAAGxCAYAAACa3EfLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9eXhcd3n3j7/OOXNmzuwjjRZLsiTLS7wkcWISyGInZHECoZSG0OVKKEsDtFdLgIR+gSctFEopITxsLbQseVoo/RHaPmzlCSEhIYQ4bvY4u+3Eq2TtGmnWM2fO+vvjzIwlW7ZlWbYk+/O6PJesmdHRZzRzzrnPfb/v9y15nuchEAgEAoFAsMiR53sBAoFAIBAIBHOBCGoEAoFAIBCcFoigRiAQCAQCwWmBCGoEAoFAIBCcFoigRiAQCAQCwWmBCGoEAoFAIBCcFoigRiAQCAQCwWmBCGoEAoFAIBCcFgTmewGnEtd1GRgYIB6PI0nSfC9HIBAIBALBDPA8j0KhQHt7O7J85HzMGRXUDAwM0NnZOd/LEAgEAoFAMAv6+vpYunTpER8/o4KaeDwO+H+URCIxz6sRCAQCgUAwE/L5PJ2dnfXz+JE4o4KaWskpkUiIoEYgEAgEgkXGsaQjQigsEAgEAoHgtEAENQKBQCAQCE4LRFAjEAgEAoHgtEAENQKBQCAQCE4LRFAjEAgEAoHgtEAENQKBQCAQCE4LRFAjEAgEAoHgtEAENQKBQCAQCE4LRFAjEAgEAoHgtEAENQKBQCAQCE4LzqgxCQKBQCAQHMpo3sCwHIqmQ75skQyrxLQASxsi8700wXEiMjUCgUAgOGPpz5SomDaW69Xv8wDTdunPlOZvYYJZIYIagUAgEJyRDOcNdNfGRWKkYGC7Lq4HjusxUjBwPBia0Od7mYLjQJSfBAKBQHBGMqGbxNUApuvSEFXRAgECskyhbJEMB5Ek8CZlcAQLH5GpEQgEAsEZR1+mRL5s4wGKJBGQZbbuGmMgW2asZDKYM3h01xjWfC9UcFyITI1AIBAIzigOTOgUTYdoSMEDhgoGEnBWa5SmmEbZcsmXLc7vasBxPUbzBs0Jbb6XLZgBIlMjEAgEgjOGnG5SMGzyZYuIqlA0HZpiIdKxEKlIiDvv28FAtkwkpJDVLXTLwbCc+V62YIaIoEYgEAgEZwSj2TJl3SJftkiEVYKyRL5soUgyI4UKX/7VTm67ZjU53URTFZJhlaJhUzQd+kQn1KJABDUCgUAgOO3J6SY4LjaQCKuEVZlg9f+65RANBfijC7vI6RXWd6a4497tPLB9iHBQwXJcBnIGO4fy/nYEC5ZFG9R84QtfQJIkbr311vleikAgEAgWOEN5AwMwPY9YUGGsaOAA8aBCvmxRNByWNoZxPPj8vdt518XLuHR5I7ppI0ngemA5HtuHCgxly/P9cgRHYFEGNU899RTf/va3Wb9+/XwvRSAQCAQLnJxuki/7ZaSK7WK5Dq3xMBIQws/WxDSFiuUSDQVY155kolShMRaiN6OjSNCWDKHIEhKQLVsMiMBmQbLogppiscg73/lO7rrrLhoaGuZ7OQKBQCBY4AzlDSLVjEy+bKHKChr+CdAEYkGFUsWmZDoUDYcNnSnWd6UYK1ToaYoQUhWe3DuO5biEgwrZssVooSJ0NguQRRfUfPCDH+R3fud32Lx58zGfW6lUyOfzU24CgUAgOLPIl23CQYVEWCURVtHAn4XgQRBQgPZEmGQ44GdsbBfZk9g9WsIDxgoVutMRdg0X/O1oan1WVN+4cBxeSCyqoOY//uM/ePbZZ7njjjtm9Pw77riDZDJZv3V2dp7kFQoEAoFgoREJKqiyRDyoEArIbBvK4wBIYAA502GsZBBVFUoVh2RYpWw5tCY0GqMh9md0ZIm6gPjelwYpVmz2jpXom9BFxmYBsWiCmr6+Pj7ykY/wgx/8AE2bmQnS7bffTi6Xq9/6+vpO8ioFAoFAsJDI6SbhoMJosYzqeYQkidWtCUbLZQygaDoUyhbhoArA0qRGRyqMXtXfVCyXNW2JKQLi9uTBc5BhuTy6a0xkbBYIiyaoeeaZZxgZGeF1r3sdgUCAQCDAb3/7W/7xH/+RQCCA4xxujhQKhUgkElNuAoFAIDhzGMobBGUJxwXd8zA9m6AEDZEwluvheh6SJCFLEA+rLE1HaYioJMIBQgGZkumfW6KhAOd1ptBUmS2vjQLQ2RgmrCqs70xhOa5o914ALJoxCVdffTUvvvjilPv+5E/+hDVr1vCJT3wCRVHmaWUCgUAgWKjkyzZRVaElrvHM/gnO7UwxUXEoGBZxTSURCuA4Fqoik4wEAepfn+3NsiShUTD8GVFXrm7hmw/v4tbNq7nzvu2sa0+yoTPFhG6SiqioslT/WcH8sGiCmng8zjnnnDPlvmg0SjqdPux+gUAgEAiGq11PHiAjsbY9geV4fkATVpHwsF2Pii3RrE69ME5GglxxVjN5w0ILKigyeB78/gWd3Hnfdm66qJsfP9PHhs4UnY1hioZDvmLTN67T2RiZnxcsWDzlJ4FAIBAIjofxkq+nkQHXc4kFA37XE4AHAUVmW+8ErQmNtlT4sJ9vS4VZktBIR1RKFYey6dCSCLGuPcmPn+nj1s2r+cET+7n/5WF002Z/RhfC4XlG8jzPO/bTTg/y+TzJZJJcLif0NQKBQHAa0z+hc2CiTEdSY0IvkwyHGSuVaYqFKZkHy0+xoEJnOnrM7Q2M6+RNm4mShW7aAPzgif286+JlDObKtCY0KraLpioM58psWtUsMjZzyEzP3yJTIxAIBILTipxuMlowiWtq1TE4zI7hPM21gKZ8MKDRZGlG22xvjNAQCZLQAlRsl5ZEqC4cfnD7MNv6soQCMobl0N0UpVixhXB4HhBBjUAgEAhOK0YKFQzLQQ1IfGvrXiLA2iWJevt2PFwNaIDmhplnU1oTGsmIWp3e7XDl6hbu2rKHd128jK6GMM3xEEsbwsiShGm75MvWSXuNgukRQY1AIBAITiuyukUkpPDAK0PceHE33/qfvUynswiG1ePe9tKGCF0NYRKa32dzXmeKSFCmOx3hpf4co4UK4yWTTMnk0V0Z+oV/zSlFBDUCgUAgOG3I6SaRoN/J9PS+CQYmDK45Zwk5wyKrW4RDCrmyXxaabft1ZzpKIqxSNv1szf6MjusxTRkqQl6UoU4pIqgRCAQCwWnDUN4gqMrsGMzzgcuW873H9vLorgwj+QoT1WndyXCQxCyyNJPpbIyQivjbWNOWqJehDnUbfq53gpwuylCnChHUCAQCgeC0IKebHJgoU7EcutMRZAk2r21lQ2eKiu0SCsj0ZnSiQWVOTPKWJDTKVcfhWhkqIEt1bU0kqLCuPYluOSJbc4oQQY1AIBAITguG8gYAv94xAsD+jM45HUma4yEao0HS0RAbulIkTzBLUyMZCZKKqOgVh6vXtAB+BudrD77Kr14ZplSx6c+Wqxkika05FYigRiAQCASLnpovzba+LM/3ZdFNF9v1GC1UODBRplSx2T6YIx4KzOkogyUJDS2oEFIVdo+Wpi1DlatDL4Vo+OQzq6DmN7/5zVyvQyAQCASCWZHTTfZn/IDhXx/dy00XdfPvj+9jIGfUn6OpChtXNtExx4Z4yUiQ5lgQ03JpTWj1MtSheEB/rizKUCeZWQU1b37zm1mxYgWf+9zn6Ovrm+s1CQQCgUAwY4byBtmyxba+LBu6Unz4h9vqwybrWppxfc7KTofS0RBBNx0qtlsvQx2qrTm7PUlCC5AXouGTyqyCmv7+fm655RZ+9KMfsXz5ct70pjfxX//1X5imiEAFAoFAcOroz5TI6hahgMy/PrqXP9nYw4auFN94aBfv+7en+YsfPMu/bt3LxcsbT+o6UhGVUEBGq7aTd6cj7BjMAxAJKpQth4rtwcwMjAWz5IRnPz377LN897vf5Yc//CEAN910E+973/s477zz5mSBc4mY/SQQCARzx3DeYKJkkq/OUYoGFTzXY7RYIaqpvl+M62G4LlpAIQA4rocsS8j4JRkJKDoOrgOyDOGAguE4qLJMQyR4VP3LcN5gvGRiOS6/emWYbb0TbOvNcvOmnilZmpFChfUdSb764Kt86q3rSIXVOdXVgF8Cu/elId6wrJFn9o/TnY7genDXlj1TskYNEZXOhghLxVyo42Km5+85GWg5MDDAd77zHb7whS8QCAQwDINLLrmEb33rW5x99tknuvk5QwQ1AoFAcHwcGrhEVAXP8+oOvYosIXmwL6Pzw6f289Fr1xCQ4N6XB3lm3wS3v2UtAUniH379Kh+8ahVBWSZTKtMYDYPnIkkyigRB/CDnyf4c6zuSSK6DJ8kokkRQlqYdZ7BjME++bKEFFb724KvcdFE33926l627MvXnbFqZ5nPXn8uTezP0TpR5rneCv/6ddX5b9xwHN4PZMuO6ieN6vNSf48Htw0cceHn5quY51/eczpz0gZaWZfGjH/2It7zlLXR3d3P//ffzjW98g+HhYXbt2kV3dzd/8Ad/MNvNCwQCgeAkk9NNXhsu8NS+cV4ZyLFnpMi+0SI7h/JsH8yxZ7RIxXKIqDLxUIBfvTLEZ+95GdvzyBQNxooVBnNlTM+lo1HjtmtX85Vf7WCoUOGq1S388cXLuOPe7QwVDD541Vncce92BvJlkhGN/9k9BrLMQL5MxfUwANODizqSjBUMJFkhhIQCuK7HaKZ02Przhk08rPKbnSN84LLl3P3EfjZ0NfAv77mQf37n6/jB+y/ir39nHXge6ViIDZ0pHt2VYbxksnXXGAM5Y047ktpSYfSK71sjRMPzw6yCmg996EO0tbXxZ3/2Z5x11lls27aNxx57jPe///1Eo1GWLVvGl770JXbs2DHX6xUIBALBLKgHMHsPBjDjJZOQItMUDTKSr/C/f7WDwbxBrmxhux7/+/4d9GfLWJ5HSJW5dHljPVCxPdg1UmJ/RufJPeOMFCpkihXecUEn0ZCCYXkM5sqsbU8SDQUwbbf+f3/KtYZuOvXvi6ZDwXIwgHAogOl6mBJYQAUw8PUzk0loASJBhRf6shiWO43RXoloUCEgS1Rsl4rt+n+LskVLQmO8ZPLIa2P0ZUoMZEqM5o1D/2zHTc23piYadj3Y8tooAJ2NYcKqwnmdKZqiIQpCNDznBGbzQ6+88gpf//rXueGGGwiFQtM+p6mpSbR+CwQCwTxT053UplO3JEJIHmzrm2BJ1UulKR4iGpK57ZrVfPWBnVy2qhkJib+4YhVffXAn16xtpac5CjAlUGlJhEiGVXJli2jIP51EQwGKhoMk+dmK1oRG0XCQJYcNnSmKhoMi+Sf9QtnC8UCRHJAgpqkUTQcPibLpUJGnqmpDAZkDEzpLq6WohmgQx3K4/S1ruePe7axtT9Ka8F+TpipcsqKJAP6JLhSQp2ynFuS0JEJkShapSADHchjNlGhOR2f9926JhyiZDiFTJqQq/NNvdnHr5tXced/2urZmQjdJRVSWpsKz/j2C6ZkTTc1iQWhqBALBmUJONxnKG+TLNtGQgqYqKJLEc30TnLM0iSpJjBYNdo/qOK5HT3OUvaMlWhIHTePS0RAP7hhmQ2eKloR/ATuSrwAQCQaY0E0ao0HGSyYNk7QpMU3B8+DARBnwMxSKJLMvU6KzMUxAlhnIlmlPhbFdl4DsBxz5soUkgeeBLEl43tRuoWgogCxJrG07ePwezZQwPOjPl+sBVUxTKFVsOpJhNODfnuqlvSHCQM5gW+8EG7oa2NCZAqBiuzRGgziuhyJDRzJMSJJoOQG9S/+EziOvjrF+aZKhvMEPntjPTRd1c/cT+6eIhlNV0XCn0NYck5OuqZmOwcFBent753KTAoFAIDgOhvMG2wfz7Bwq4HrQkggRDwYYLxmMFMqc35kiW6owVDCIhFTWtCVoSWjVzItGSyJUz2IYtlM/ARcNh6Lh1B+LaQqhgEwk6H+NaQoxTSGhBShVbMDPiCTDKqWKjRqQ6v8PBWRG8gaRoFL/PhpUiIdV4ppKPKwSDQUOfl+96RWHgmFxYFIZqjkdRQsqLE36wZIiQ0CWpwQ0G1e10JYM88pAjj/Z2MMrAzmG80Z9onYkqNSzTYWKQ8XzOHACWpuOhgiXr2pCNx1aEiHWtSe5+4n9vPeSHjatTNOSCNEQCZLQVPqzOgPCaXjOmFX56UhcddVVvPrqqziOM5ebFQjqjOYNqNbdi6ZDvmzRElcJBvy6fNl00E2HRFhlSSI0522bAsFC5kCmRKG6XyTCKrGgQtmxUSWZxqifaXlm/wRr2xOoiozpeIBXD1pqX2ulmkhQ8XU31aAFQDdlNNUPRobzBm1JjZG8QTTkP96eDKObNjsG8ziuxyUrmnA9j+d6J3hddyOKBGNFg40rm/Bcj45kGMmDkWKZcDBIPKhQMB12Due5oKuhnqjxoJ7FKZgOw3mjXmpqnpRdyukmI4UKw4UK4aDC21/XSbFiUbGcenDxgctWYFgOD24fpj2p0RwPEQrI9TKZJMF4yRfxzrb1uqMxQsl0yJRMNlQFw+0NGp+/9/AylOl65HRTHK/mgDktPz311FPous4b3/jGudrknCLKTwuX/gmdvGGTL1skwypxLUDHIS2cA5kSqgeG5Ac0imSRUjXKHgzly+zP6KyppqV10yGsKjRGVDqPUB8/2KpqkwgHaIgE6wdJgWCxUQtoatqZSNUzJiD5AcFoycB0IB0LYTkenutRrNh4QKli05IIMZKvsCSh8fyBLADndCQpGDa9mVJdU7N3tMQlK5oYLRi4HiTDKmpARgJUWeL5A1ma4xqS5M9FGiuWcT2JlrhGALAP8anRXZsAfmlMliDkwWC5QioSQmOqV50JuMBg3iChqfX9/WjUynBZ3SJcNcb7zc4Rnu/L8oHLViBLsD9ToneizJvObkWRZIoVi7GiSSqs0tk4+/JQbWr4/nGdVa0x7rh3O++6eBmjBWPaY1UirDJW9NvnE2GVpujRfXrOJGZ6/p7TTM3rX//6udyc4DRgdELHcj0cDmZWaleQCqAqMmXH5fE9Gda0JQgHFbJli4rt4roeWtWfoi9TIgRUJKi4Nk3BAKBQAZ7Ym6E7HWFFc4SQKqEFAqiKTKFsUTRlDmRKLD0ksOnNlLjjl9v5/Qs6aUmEmChZOK6HaTlHDIIEgoVKf6aE6Xq4rodUDQ5cz0PCw0Wm4tk0xcLkDAvL9igYFpIkEQ+rmJbL3tEi0ZDCSN6gJx1lRXMMgJ2Dec7pSLEkqSEB46UKG1c2UTIt9mV03rCskZqW13U9SpbNurYksgSm61IybdLRMKnIQT+YunC55nsTDODvzf5N9zzSkRCTT+U1kz61+v+4ppI3ZtY5lKwa+PVP6IwWTQzL4crVLVy5uoUdg3m601Ga4xr3vzzEppVp0rEQcUmlYNhkyxaRogmeN6vjQjISpFCxSZZVLNurt3jXJnnXMjbjJRPdtGnzPAYmyhRMmwnd4sm941xxVjNtQlA8Y04oU2OaJiMjI7iuO+X+rq6uE17YyUBkak4to5kSFQ8c/MBjuisTBejL+WLC3aMlWhMaHtDTFCUBIEtU8NPNyaBv+qUgoUiAB2OWg+X4B+UNnSksz+OJPeOHGV1tXNlEV/WgNJw3+MzPXzqsI6Eu3EuFRWAjWDQcyJQoWc7hguADWTYsTTGul0lHwxRNh6xuIUsQD6t41YyJBKgBmfFihdaERsm0ePFAnmVNUVrjmh+0eOBVQ4ts2SQaUmmKzU0WoSb0tT2bmByol5ZrQU88qFDrsbXxgxur+py1M8jUTOZIWZsX+rLc/pZ1yBI81zvB65c18p/PHGBDZ4poKIDjenQ1zP640JcpMZAzCAeVY5ryXbIiTbFiU6z4x8lQQKYtqZ3xGZuT6ij82muvcfPNN/M///M/U+73PP8qYaFqakRQc+o4MKGD6x8GB6pBy/6Mzrr2BCFVwbZd/4pSAVXy6/cevnJdkiQcr0xUCmNKBzM87UkNl6nq9tqBIqEFGCkYqDKkIn5gdFBfE0DCoyESojmhsX0wz0C2XO9IuOf5fj5w+QpkSZqSuleAkKpMqdcLBAuJvkyJx/dkWH3IBUMoIBFRFcZKFVpiml+WMvwTuSLJSBLEggo1W2DX8wOcTKlCMKAQDQamZFdOFgcmdGTXQ/I8TCT+79O9vOf1Xdge2NV9v7ZPxoL+mIVa1sb0wLAdliSO/4RfK3fXAqewKjNWNPA8idaExlBW51tb9rKuPcm161o5MFGmuzFCQgvMOrDZPpjHclxGCxVeGshxcU/jtCXzUEDGw0NComBUA9WAgixBpCrmPhM5qeWn9773vQQCAe655x7a2tqQJDGhS3CQgQkd1/VwXA/Xg0RYRUJifWcQCX/2SzCg8JVf7eAj16xmpHjQ8Ko5pvH4njEuW9mECRSq3Q6JsO9fcSiJsEpOt1AVmZZYCEmSGSmUcTy//dN2PSzH1w6EA/7HvVC26h0J//PaKH95zeoppTHLcfnaA7v44FWrMF0PI1MSmRvBgiOnmwzmynSlI7zUnzvkit/g/K4kkaqJXe3knSubdCTDyEBsmhEBp/pzXjBsP7iSJP7vU72858Iusq5DQlYOPmnS6aWmw1Fcjwp+O/aOoUJVDzfzxoCOhghepoQsQb5s47oKjVGNoCzxyK4RHtw+Wm/BvnZdK6GATN6wsRwPST7ok3M8NEaD7Bsr1U35ShW7PvRyTVuCSFBBrx7jGiMqjuuhxoLc//IgT++b4AOXLUeWwLCcetZZcDizCmqee+45nnnmGdasWTPX6xEsckYzJWx8g67aMLfawaE2l2VDVwPbeie4eWMPT+8bn/LzsZDqm3VVd+5aQBNWZYar/hiTaU9qVCyXfNkiltR4at8453WleOlAjvM6UwRkuS4+RvJPBPGwSla3uGRZI0sbI2zZNVY/IZRMh+FcmY9sPot/ePBV/ugNB0upIrARLCSyuq9r6WyM8OD24XoZ1bAcupsigISmyJQsh7jmZzpiwTCJkzDMcbbkywd1MTe+vosKEJQUP2M7zfNdwHQNLIKEqt424aDCuG5SthyaKvZhDQZHIlexaQwFiKkKedNhMOc7KbcmIlO6pHYM5usi4lLFoWDYs3qtrQmNrG5SrNiEVIVXBvJ0pyNH1Ne0J8Nki2XedPYSzmlLcdeWPWxe28qe0RISp/54dGBCpzCpmSOmBWYV3J1sZuVTs27dOsbGxuZ6LYJFzuiEjgE8umuM3aMlvvGbXaxrT/LdrXvrX7fuyrChM8XWXRlaEqG642jtljdsKrYfpOTLVv1gPFY0SITVw26y65GOqvVMzvou34PjvM4Un73nFX7x4iDFis3esRJ92bKfjamWq5Y2+q2n3elo/Qr32d4JHtg+zGDO4H2XLScaCtS9Kway5fn+EwsEdUqmzZq2BHdt2cO7Ll5Ge/JgWcKwXJ7rnUCSJAzTIR70tTad6eiCCWjAz7TW9nUbXztXu9IOeBAPKjTFQriux1C+Qt5ysD2VkCwzXiqzYzAP+K3nZcthrGjO2F9GrzjYQL5io8gSveN63Wl4Q2eKzWtbkSVojmtsH8gxkq8QCSoUZihQno4lCY2RQgXTclnTlmD3aGna969sufzP7jHSUY3ne7MEVYl1VbfkloRGoeL4Jf5TRF+mRE63/Mya5jdiDGR1+qaZxzXfzCqoufPOO/n4xz/Oww8/TCaTIZ/PT7kJzkwM16NQceoByuQApvYVqM9fmWzkdaihVy1oUQP+QLuWmEY8qBAJKtUrTv/myRLFikEsqJAvW8ieRCSk8tl7XuG9l/Rw+ao0y5oirG6NkwyrDOYrFC2HlBZAkSQqtociSXQ2hGmOhehqCPOui5dx15Y9RIKBuuFYwbDIlcWcFsHCoVTNZp7XmUJT5cPmC63vTOF4Hs3RIEvT0QWpDYtrgfq+rldLwEF8vYxEVRTsuOimQySkoCoymqKgAYYN3dXS22ihwnjJJFMy2fLa2IyGVCarF0LZss3ARJmLehpY2hAmHQ3SHA9xTkeSx/dm+P89vo9PXLeWHz3TV12zyr6x0qyGUSYjQa44q7leZpo89DIgSzTHQyxtCBMJKqxrT2LYLud1+WLlWjNDxXYpGNasM0bHw8CEzv5MiaLpUKrYJLQAqVCAXNnwdU2ue9g8rvlmVkHN5s2befzxx7n66qtpaWmhoaGBhoYGUqkUDQ0Nc71GwSKh1rEweXDcoV/h4AyWWgAz+TaSrzCSN+pBy4t9WWzXRULCcG1UQPVAq95kD6JBjef7cyTCKmXLnxtz4bIGOho1PA/GChWe2JthKOdPFe7PGjyyO0PRsgkoEAkplEwH1/NYvzRJLCRzXmeKsunUXVLjmnpCV2gCwVyTCvsOu1eubuH7j+3j1s2r+dEzfYzkK8Q0hXzZpmw5SPLC1TwubYgQr+7rhaqmDfzWbkfyy01utfNKliSCslRv9d6fmT5w8fBmNAG7NRHyy9aawtO9Ezy9b4K4qtAcD6FIEqWKw1VrWrjpom6++sBO3n1JDzsH88SCCn/9sxe596Uhdo8W2TNaPK4Apy0VJhmeOvQSqJehfvXKMKWKTX+2zIRuosoyhunUh3SGAvIpOR71ZUpYtkMIX1Qer874KpgOLbEwHbEQz/dmseGUZo2Oxaw0NWJQpWA6auWiYuXgFUQtgJk8TG5bX5aNK9P1AGZy+92W10a57ZrVWK7f/XRBdyPDhTJhFZLhMEXHIa4cFBGq+AfADR1JXGAoX8H1PK5Zt4Qn9owTkCV6miIsb47W58LEtQCRoEyxmkq1HA/PA0WWyJZtUhGVq9e0oJsOjucHYzXvCoFgoVAbnAjw+xd08rUHd/KXb1qNZbt4SMiSgyxJFE17Wq+mhcLSdJShTKne4dRfKtMRCWMztbU7Vm3t9oADRYN17QkKhn2YnmhZU5R4KEBet45aaktGgiTCKgPZMtsHclzQ1UDFLaNKYZ7oz9ESDzGh+27Kl61qRpbgouVpfv3KAFt3Zbh5Yw9/898vsaGrgef7svzd751Dwww7xqIhBd1S6kMvXzjgt3nfdFE3P36mjw2dKTobw36WuGKzJKEBHq+N+HqarnTkpB6PDkzoTOhlmsPhg+1mVbzqTZZkLuxK1T+DC4VZBTUL1TFYML8kwioBRaoHKhtXpusBTO3r1l0Z/vXRvfzjjRv40TN93HbNaiZKBwXAPU1RvvrATv7owi7OTrtEZJm2RBjT9chXbPSKgxf206IvDOR5cu94XXh84+s7WdUax/HAsj1aExptyRDBgMKXf+Vvc2ljmIrlIkuyH9yoCgO6QVwLMJw3+PEzfXz02jWoioeqyKiKH4w91zvBxSua5ukvKxAcTjISpLlic2CiTEsixB+/oZuAJPGN3+7m5k3LiVf1Komw6jsK540FWYICWJKO4ozrBD2PxkiYkueCJxGpesnUshJSUKFkW4SD/rHmKw+8Wvd7qWFYLs+NZbl0BvtrQgvw9Wf6+Pib1/LF+7azvjPFDetbuGJFmnzV+ycSUuhpihKUJQazOp/5xauAn32uBTffeGgXf/2zF3nr+nYuWZ4+ZnBj2y7piMr2gTxLquX6de1JfvxM31EnegdkiUQkxPO9E7xhefpE/uRHpWDYNETCvgP0EUxfPCAsywwZxvRPmCdm7SiczWb5l3/5F7Zv3w7A2Wefzc0330wymZyzxQkWF3EtwJN7MrxheSNjhQq3XLmSu7bs4U829nD3E/v5k409AGzdleHDP9zGzZt6yJYqtMT9A21t3/n/rl2DYTvsLVooMuweKdIc1/j3x/dx00XdfPO3u7jpom6e78vWt/2hq1bRltDQqrNq8tUyWCQY4M77dnDbNavJ6RXGipW6mZblePTrBm3xECPFCsvSUT6y+SwOTOi0JTWiqsJYycBy4MJljbQLV0/BAqOjIUKxYjNesuhMR/jKAzu5dfNZPLl3vO7QnStbmLbLQh8E3dEYYSBTQgMsWcbG926pZWoSQYV9GR0lINGRDJM37Lqe6BcvDtY1e+BfUPU0x47ptdPREOET163lzl9u56aLumlJhDiQd0hoEgktwKd+9iJP7vMvyP5kYw8f/uG2+s/Wss+10notwKkFN5etbDri3ChJkhgplLloeSOZolkXJ2/oTHHnfdunDdS27hrj0hVNjBUNLlzWeNI6j3K6We9K04JK3S+oFiAHFIlv/OY1/vyKVSj4GqOFxKzM955++mne9KY3EQ6HecMb3gD4c5/K5TK/+tWveN3rXjfnC50LhPneyac3U2I4X8bDL9ngSZiOg4RE9R+u58+aiWkBHMc3/QoFZLK6SSQUIBxQ0C2bUsUhGgogSwczoJO/1lxOw6pCQ+Sgu+lwtsx42WIgW6Y9FWYg69fX13em+PKvdtZHIxQN35gvHgpQC1cmD8pMVtPhIUWmWQQ0ggVKbb6QLEs4rlufkF1z6J7sXbNpZXpBWxPkdJNy2ao7Bk8uPRUNg2AwhCpLlG2HQtkmGJCntENP7mJ8ZSDHp996Nt1Nx369h5rxxbUAlu2wZ8zXimzry/Kvj+6tC3w3rkyzoauBbzy0i395z4W879+eBuCf3/k6/uIHz/Iv77mQ727dyxduWD9tYFOb01UyfGPBAxNlKrZLZ2OYh3aMcHFP42Hv31CuzMqWGB2p8Izb1o+XgWyZT/z4Bf7qLWsxLYt0VKNg2nhIkzRPHjE1wDcefo1brlyFhAeyfNLbu0+q+d5tt93G2972Nu666y4CVUMz27Z5//vfz6233sojjzwyu1ULFj1d6SiKLPkTsy0HveIHDolQAMs26M97tCZC5Mou//Dgq4elWofylfqogmhA4dE9GZYkwwQUiYaIiu145Ms2/Vmdi5enWV6dUTOZ1lQYB79kFAsFaEmE6EpH+PKvdtZ/33mdKa5c3YLjegzmDFIRlYSqTFHO12rHnuMe9jsEgoVCbb5Q/0SZ5niIVwbyR/SuKZrOgp4GnYwEyZctRqsZVQkJ1/OwXI+opjFRMoiFg+RKFs2JEKWKXfe/+sZDu+rbqWVWdGtmHUIdDRE6prk/pAb4Xz9+gUdeO2hhMjlrUyut158/KXvz6K4MveM6nudN8QYaqHYLRQIykbiG63mMFCp0NUYoGg5Xr2mpa4VqxymAaNBvWHDdOZtBXSenm2R1i0/+7EW27Mr4s/mCCngeTUF/dIUE9Ys9SYL/740rGDMdYkGFzgXkVzOroObpp5+eEtAABAIBPv7xj3PhhRfO2eIO5Zvf/Cbf/OY32bdvH+CXvP7mb/6G66677qT9TsHxc6SriNeGHWKaQ9n0MzC/f0End963nfde0kNQlaYIeftzZTqSYb63dR8fv24N3/7tnsPSyxcfpabcngqzaWVTfd6NIsn13/eui5cRCcpTXFhLpsOzeYNNK9IoMsiShOd59YnCo5kSzQv4CldwZrO0IULBsCmbDmvaEnztwVenPdlvWpnm768/d8EGNeBr8xwP+rNlcmWLkCGzrS/L9oEct79lHfe/PMgVZ7Vi2i6qIvPdrXvZ1pvllqtWTsnWDOXKdDWeWIa1PRXm6zduYChvcGDCLwdt68vy4R9uY0NXakpJanKAUwtusmXLt4aoHodqhRFZdlDlALlqtuaS5Y2ULX+Ib1CV61qh6Y5Tw3mDKxR5ToZc5nSTCd3iUz97kfdu7GFL9RhrOTpBJYKMRMmDz97zMptWpXnzmiV4+DO4xmyPQtlCwp+n17pA9FqzCmoSiQS9vb2HOQr39fURj8fnZGHTsXTpUr7whS+watUqPM/j3/7t3/i93/s9tm3bxtlnn33Sfq9gbmiJh9g+VECRJGzXoyUR4sJlDbQ3aHz+3u1cuKyBa9YtwbL9uScl0+Ff3nMhX35g57QHrSf2jpOOHnmoXmc6Sn91ZEPBODgaYbRg0J0+PPDyPI/BvEFTzB+fp8gSiiwxVirTEA0zOqHTvICuSASCySTDKv0TZUKqXHfE3dDVwM0be6aUZf7uF6/w5T84b8EGNrVsjSJT7wB609mtbFqZZmCizDP7Jrhm3RJ6MzorW2LsHCrwjzdumDZbc8kciGlrU76XJDTGir5o99Llaf5nj68N1E3niNmbUEDGsB1Kps1zmRLnd6bIVyekt8QVJMmjMea3kEdUGVmSyBt2/Tg1bcYtHakGS8qs38NaMPPY7jHuqeqRbryou/74T54b548uiIAEn/1/L/P+jT10NkSwPQ/P85BlmWjQt+Qomw69GZ2sbs5qDtdcMytNzYc//GF++tOf8qUvfYlLL70UgK1bt/Kxj32Md7zjHXzta1+b63UekcbGRv73//7fvO997zvmc4WmZv4ZypbJGRam41I0HJriQe6418/W1IKbQ6dmd6TC9GV0vvnI7sOyNX9//bksO0bNvC9TolBxyJUtdNOmtZq2nn6YnIQWUBguVEhUB1uqHjw/mOPc9uSCbYsVCAB2DuWZKFkYloPtedz9xP7D9qdYyNeR9UxTul0o1E669WxNYGq25levDLK6NUFYVYhqAf7hwVd5fM84N2/qmXLhM5w3eMs5S+b8RFub9j05e/Ovj+6dkr3Z0JViQ1dDfSBmKCCjqQr7q+UnCYlNK9MYrk2+ZJGKhtAkiYGC3+jQHA/xtQdfnTaTXaxYdCTCdM5AL3QoB8Z1trw2yj0vDnLzxp66HmiyNigSVPjxn/vn9l+8OMgNGzqo2A6WbZEKh7E8l7FC5XDdVt7girOa5ySLdCgnVVPzpS99CUmSePe7341t+zVLVVX58z//c77whS/MbsXHieM4/N//+38plUpccsklp+R3Ck6cJakwUl5i71iJhBbAsj3WtScJqhKfv3f6UtRgrkx7Q5idQ4XDsjWP7ckcs32yMx2lL1PC8zwmdBMtqFCq2HQ2Rvjmw7umCIcDSgBFlgjIVPU2ZdoTYTa0J5lYYH4MAsGhLElolC2XkCrz9YdeO2IJ6u+uP2ceV3lskpEgJcM+Yrbm6X0T6KbLurYE3/ztbjatbDqituaS5ek5D2omZ28G835L89dv3HBYaWryQMyaKenkMk1Gt0hHVLSYwrN9WVqTGg2RIKNF3+Zicib70BZvB45bH3VgXOcTP3mBmzf2sHVXhndOys5Mtt2ouTsD9eOth0RDJEx/rkxvdebY/rESl1XL/PmyxfmdKWzHZWhCZ8k8ZbVnFdQEg0H+4R/+gTvuuIPdu3cDsGLFCiKRk/8iXnzxRS655BIMwyAWi/HTn/6UdevWTfvcSqVCpXLQA0WMcFgYtCY0PNfDdFwGcwYbOn0b8Mk7cE0g53p+KcpyXH7655fw6f/3yqwOWrXAJhlWkTyJ3aMltrw2elRPCNkDw7KwPRdFkoWjsGDBU/OuyepWfd7adKXbx/eM0xg5cul2IdDe6Jc7+ibK1Syrn615ZSDHTRd18+EfbuPrN25gy2tj/PXvrOVbD++akskFv836U//9Et+4ccNJea21bXoejJdM1rUl6sHNoQMxN3SmgKnu6oblUDT92ePndaYoVGyCilx3i75m3RI+f+/2+lBgVZHqwuHhvEHFdqas42gcGNfZP65PCWYmm6LW/MPA/7vV3J0zpYMt3hIQDQVY05bgF88PcNNF3Xz+l9u5+ZJu2lO+EH0gZ5AMq9jzZPg4a58agEgkwrnnnjtXa5kRq1ev5rnnniOXy/GjH/2I97znPfz2t7+dNrC54447+Nu//dtTuj7BzFiSCpPTTUqmQ6ZkUjQO7sDvungZmjq1VTNTMmmIqHz6ret4bfhJ+qpp3+M5aNVaWfMVm9aEVhcO33xpD+l4cErbYsm0iakB0tEQHr5d+0LzYxAIpqOjIcJgbpwNnan6iepUZTDmmmRYZevuDC3xUN3LBahnQ2ralZxu8ZfXrOavr17F/3t1hO7G2BQdUaZ08jq+kpEguunwXF92yjrbk1p9IOZ9Lw/RntQYqF7E1YgEFYqGTVQLULb8knzFcljaEGa8ZNUz2Xc/sZ93XbyMWEhGN22ioQCuB5bjsX2owLLGCEumKfmM5A2Mio0kS/RWg0M4GMwcmp2p+YfdvLGHWNX4MFmdzeXhdz+5nu+I/McX+wHNx9+0mrAkM/mSr9Y5Opwp0XqKA5sZa2puuOEGvve975FIJLjhhhuO+tyf/OQnc7K4mbB582ZWrFjBt7/97cMemy5T09nZKTQ1C4jhvMGukSKJcABFkrn3pUHakxoPbh/mXRcvY7RgHKZ7aYyoDEzoZMp2/aB1w4aOadu7p+OpveOMFit0NoZ5bM8Y165dwp337TjMvyYRCqDgMVAwaI77B4xuoakRLAJ2jxTZOVzglcE823on2NabPWV6k7mm5p2y5Qht1brp8PNbNlIwbLoawmge3H7PSzy4Y6z+3M/+3jmsOMkaoprOJqtbhKsBwW92jvB8X5YPXLYCw3L498f3sXlta/1nzulIokgSxYqNBIRDCgFZJqn5QUt/tkyxYrOtL8vydIT1nSm+8dBrvP+y5USCAcqmg276x6tUJFgvbeV0k1zZYjhfpjmu0Z816tqk9/3b09xy1cr656IW9E7Ocl2+qokvv2M9OC5lwHa9alZIwnZdSoZDMuKPmFjfEpvi75Wo+nsZro0mBdAUaU4aLOZcU5NMJpEkfwBEIpGo/3++cV13SuAymVAoRCgUOsUrEhwPrQmNiuUwkCsjIdWvYmqTa7vTEXYM5lnXnqApHkTyJPIVG1lRaE8FeHjnKK8M5Hj7hulcJqYnFVHJGxZFw6kHNLdds5qn940D1D12Xshl2biyiSUxjYLpT/YWCBYDTbEgw3n1tMjWtKfCfP76c+qZhppoeHLnEUCubJEPq6AF+PTvnsO1Z4/ymf+3g627Mnzm5y+ftBJUjZrOZnJwc+XqFq5c3TIluJk8X3THYJ4LlzUiyRISkCubdCTDtFeDgELFJlMy2dCZoisd4RsPvcatm88iUzRQAxIxLYAs+xnmkCIzkCnh4GdJHt01xvLm6JSAppaZOVhq2jslOwOwtCE8pYtpdELHBILBAB7QnzPR1AD5ssXSxhAVoFg16KtRrGa6JTysU2zzNavup/ni9ttv57rrrqOrq4tCocDdd9/NnXfeyf33388111xzzJ8X3U8Lk5xukin5VuF7x/zOgKUNYXYM5qe0Xrse3LVlz5RujoaISktc459+8xqf/t2zZ3TQyukm9740xPqOJLIsMZwzCAflaR08VzRH6UiGGcgbvKHn5M1aEQjmmv4JnR1DBbb1ZdnWO3GY3gTgslVNJ/1kPxfkdJPtQwW+/tBrh3VA3nLlKp7cl+Gc9iSRYIBUxC8Tx4IKkgd7Mjq257GiKTojd+G5XPNIoVJvv9YCCp7kYZgOrwzk61nfZCSA50Es6F80TXZ8rmWyc2WLZekotuuyd7TIhs4UlufxfG+W87tSqJLsa/9kmYFcmXhIZShv0JII0Tdergc0NT1STWtVy97B4cHMdK/HLFsYgIuHbrqkggoOULR8h+doSEFTFQKyhOJ52B7IsjQnLtYntfvpqquu4ic/+QmpVOqwX3r99dfz0EMPzWazx2RkZIR3v/vdDA4OkkwmWb9+/YwDGsHCJRkJUjRsLMclGVYxLF/8tqYtwUv9ufrzJpekWhMhtKCC5EkYtsONb+hmqNqFcKwDdDIS5IqzmilbDqOFCp3pMGOF6bN9AJbrkRB6GsEiozYXCuAbD+0iElQOK0GdbL3JXJGMBOlMhXnruW11351QQGY4b2BYDs/3ZbEcjzed3UqhPFXQv7wpguu6/PNvd/Hhq886ZTPckpOE2H2ZEpmShWE7RIIKa9oS7BzM84aeNDIgSUw7jqU1oWFaDr34Qz3jYZXzOlMMFQwk4PyuFLIk0Z8vkwyrjJcqJMIB8oZNxfY1OocGNNP5F3U3Ro44p2ry66GaiSqVLeJBBQ8wXQ/Pw2/qqFZwMsUyjdEwIZlT3jU6q6Dm4YcfxjTNw+43DIMtW7ac8KKOxL/8y7+ctG0L5peOxggD4zrhBoWtu8aIhQKEg8qU9sfJJalSxaZg2Hz/sX11Lcx4ycJ2PQoV+5hzSNqqQuWK7Vat2DnM5GpZU7QezDREF/ZBXyCYjiUJjQMTZSJB5YglqOMp3c4nHY0RNq1qpndcr3cQDeQMHtw+zE0XdfPDJ/b7At1qYFAoW8TCKoWqlf+HrliJ4rjzMiaiMx1FUfzyWW2+1MXL0yiAosi0HiXQ6kxHQZIoGHbVwVelMRpirFhhpFDBcSERDuAhkStbyJJETFPQTZmYprB199iUgGZypjsZVmcU0ExmcpmtpFuossTkS0JVlmiNhnm2P8t5S1OnvGv0uIKaF154of7/V155haGhofr3juNw33330dGxOHYQwcKjvTHC0ITOpSua0C2HnG5NaX+8cnXLlMzN0VqyPdc7ZsrTtF1iQQXT8bhry576Tg++N0NW93fGpaHAgrEAFwiOh2QkyNKGMDdv6jlMDAqcMr3JXNHZGAHPoxdfQ1Mrnfzwif184rq1fO2Bndx+3Vpqmop89SQPfsePK0vYZWteXmt7KjzrLFFnY4QD4zqS5L+mWChANOSfvvvGy8iShCz5WZmYpjCSrzCSN4iGFLYfJaDpOs6AZjKVsoVTneBdNGziWoBQQKZk2UQDAS5cmmLCdE551+hxBTXnn38+kiQhSRJXXXXVYY+Hw2G+/vWvz9niBGceSxoi5HQTuewLdkOmPOXxycHF5FlOtZJUSFUwLZfBfAXdclmSCB3xAFaxHAzHxrSZ0jY5mCvXn2NYLlt3jaFIEh2z3PkFgvlkSULj0uXpeoZmujJUVp+fE/1sqFszhFXyhs2bzm5lQ2eKrz2wk09ctxYNeOJAltVtCeJh/wKn1pVTwQ9u+jKlBT2tfDqWNkboq7oRFwwbpzrYshbIKLLMll1jbFqZ5sfP9HHrNavJ6RVuf8ta7jjEqT0ZVulqCPtB4izxJ6n7AuFa6aliO+gVi3BMwUWiYFgnfXr3oRxXULN37148z2P58uU8+eSTNDc31x8LBoO0tLSgKMqcL1JwZnGwFl1i+0Aer3rdFQsFpmRuOhvDU0pSBcPmn36za1I5ysR23SOWo1wPMkV/2OWGzhSqIqGp8jTTjaPkKzaxBTzdWCA4EslIkGDVl6RWhnpqT4azWmL1NlzdcujLlAgB0jTajoVGZzrKgQnd7/wxLNpTYW6/bi2a63FAr3Du0hT//JvXeO/GHl97V+0QAqAa3ByY0E/5CfdEqZmIuq6HWz0ubt3tBzLJsMr2gRxv6G7ko9eu5iu/2skfXthFOgZ/89az0S2HgmHRoak0RIMnlH3O6Sae5xEKKFOOyaGAQlxVeKYvy+u6Gohr6inTMNU4rqCmu9t3IXTdU9yjJTgj6UxH2QgM5Q08zyMRVuvCR4Ci4UwpSR1POSqnm1iey57REhs6GxgtVrhydcuinm4sEByJhurn9uZNPTy1xx9e+L9++uKUctSmlWk+d/25hGx3UUylX1rN6g5JkC/buK6HFVSIR4L8829e48+vWEWmaCBJYDse8apD7qFC4sVGLbDpzxmAVw9ktLjMp966jr+75xUuWNbAbdeuxrI9xgom8bBKYzTI2ra56fo1yxaeJFGxDnrTBBSJb/92F39+xSou6ExRMP0xN6eaGbd0//znP+e6665DVVV+/vOfH/W5b3vb2+ZkcXONaOlenPRnSpiuhyJLbN2dofaRPW9pCsfzGJ3UufSDJ/bX68e1UQsAZdMhFQnWy1EHMiX6c2V2j5ZY3+FPzo1pAX71yjC7RwpTjPjiWoDhvMFPnj3A598uAhvB4iOnm3zoh9t4z6XLOKsldlhAU2PTyjR3vN13iVcU+ZRfZc+WvkyJoulQKPsdQmFV5vm+LOd3NiABX31wJx+6+iwcz8N2/ONHrTSyWF7joRyoHhddz+OOe7dzwbIG3nz2ElRZ9v8WVUFyMjz32ZK+6vHz0CGb7Ykw//Twa9xy5SoG59gGY6bn7xkHNbIsMzQ0REtLC7IsH/F5kiThOAtz8J8IahYvw3mDCd0kqMiMFSt4nkdzTGO0WCFT8jvxOhvD3P/yMK8M5OqjFiZ3R9WcgpNhFWwX04Oy5VCs2LQlNQZzBqbl0prSeOlAlnM7U1i2R8Hwr0SiQQXP9ehewNONBYIjMZAtUygVceUQ1/3DkbtUf/mRy+r/n6sr+1PBQHZqd1EsqFA0Lb7z2z3ces1qFODrv3mNP3vjSmQJypbLV361ky/9wXmL9kIlp5sUyxY2vuN6wbBIzEF56WgMTuiUbYeRQuWwoKYl7o+VMW0/rJjLz8+c+9RMLjmJ8pPgVNOa0GhNaIxmywQTGpbr+1emIgdLUkXDqXdDDObKRy1HdabCvNg7QUxTqdgupu3SnAihyBLZUoXzulI8sWe8bsZXMh2Gc2U2rmiavz+CQHACtKfC9DkuAznjqM+rl2cWhmn8jKl1F/VP6OQNm8G8QVxT+eg1q7Fdl3/+7W7+4spVBIBvPbKbP718BecsTTJWXLxaucleOKcK2/VwPfj6Q7sOK19+5m1nE1JkMoYxb3qlI6dcjpNsNjtXmxIIjshY2ULxfC+Esu0iSzBSqDCcN0hogfowuckDK997SQ+Xr0qzrCnC6tY4ybDKYL7CmrYESxIaiixhuR5Fw0KRJCQJTMulOx2dYlL2wPZh+nNlRvJHPykIBAuVounUpy8fiXhY9W+L1HCyoyGCbdu0VzMVg3kDw/a45cpVKJ7Htx7ZzfsvX0HI87hydcsp91FZ7LjAp3/+8mHly0er9gC14b/zVdabVVBz55138p//+Z/17//gD/6AxsZGOjo6eP755+dscQLBoeTLFmXPxXJdJAkcDy7qaWRlS4ywqpAM+5mXiu3Skghx4bIGOho1PA/GChWe2T+O43poqsyE7pv1ndUaQ5Ul9oyWqNgOLTGNnGGRCAdoiARpiYfYtDLNey/p4a4teyhNEisLBIuJfNkiFlTYtHJ6rcOmlWliQYVY0N+XFiuyovDzFwdIBiTaasFNzqBgufzp5StQXY8x09+PF2vwNl/opjOtHgv8wEY3HRLzOCdvVkHNt771LTo7OwF44IEHePDBB7nvvvu47rrr+NjHPjanCxQIJpMIq/RmyowVK2R1E8txGS1USMeCyBJ0NoRJhlVCAZmi4XDNuiU8sWec/RkdgO50hJf6c4wWKoyX/JlTj+8ep6sx4s8rkSVM1+M7j+zh/peH0U2b3nEd14OudJiLVzSiWwtTMyYQHItEWMVwLT53/bmHBTabVqb5+7efiwposGgFtABaQOHpfRPsGjfoz5WxXRfHA9t1/e8lib4Jg7Lp0BRbnKWn+eJY3WMFw6JjHlvlZxVODQ0N1YOae+65hz/8wz/k2muvZdmyZVx00UVzukCBYDLJsMrXf/0qt16zmmf2jdNS1bwUKzYjeYPLVjbR2RBm664x1i/1hb6tCY3meIgdg3k6GyM8uH2Y8zpTXL2mhZCq0BoPMVKocHZHklBA4W//38vTmvA9tjvDtWuXkCkePiJEIFgMxLUAj+0a45z2CHe8/dwpXTKxoOL71ACOvMgENYcgS/CBy5YfNgDX9VQaI0FczyMgS6Qi6qLV08wXxypfzvecvFllahoaGujr6wPgvvvuY/PmzQB4nrdgO58EpwftqXDdDr0lodGSCNEQCbIkobFpZROO6+G6HptWNhEOKhSMg6MW1rQluGvLHt518TIu7mmkYNjcce92fvnyEHnDYvdoCd106oZ+h+Lh63fSYg6UYJGytCHCRcvT5Cvw2J4MluNrxnJli4xuYeJrJpYsMlO6QwnIErIEm9e21gOaUEBmf6ZE3vBHJ4wUKiwR40+Om4Zo8Kjly/mekzeroOaGG27gpptu4pprriGTyXDdddcBsG3bNlauXDmnCxQIDqU7HeWTbz2b9lS46j+jktACSPgHs4ZokM50lHQ0SKJaitIrfrC9rj3JYNWfpjbv6ZWBHC8N5FjaEKZQtrh6TcsRf7fneUiL+yJWcIbTlY6ytCHChcsaUWSJiuXSEFFpjaiEZInWBW66NxM0VaEpHjqsgUsCmuIhPM/jyrOaRZZmFrQmND7/9unLl59/+7nzPidvVuWnr371qyxbtoy+vj6++MUvEov5vh2Dg4P8xV/8xZwuUCCYjpkMh0tGghi2y3O9E6xtS6JXDrZ8w9R5T5GgzEv9OTZ0NaAGpKOKgd0ZOTsJBAuX+dQ8nAqaExqVjENPc7TupRLTFKIhhaAskQiLstOJ0JWO8uU/PJ+JkknesElogZPqjXM8zNh873RAmO+dmfRlSpRMG8PyGJikkwkFZLb1ZeuD3b7/2D5uv24ttusxnDf4/mP7+KMLu1jaGKZi+V41yXCAsKrQdRpczQoEpzvDeWNBnngFx8+cm+8dyu7du/na177G9u3bAVi3bh233nory5cvn+0mBYKTQmc6ymjewLAcdNOmXO1eqnnaNMdD3HnfDm7e2MNXHtjJh646i+8/to/brlnNRKnCk3sPmvAVKzbDeQNVkWlbxN0hAsGZQM20U3DmMCtNzf3338+6det48sknWb9+PevXr+eJJ55g3bp1PPDAA3O9RoHghGlOaOBBe0pjJG8wnDfqnjYAW3dlaEmE6GmOYdgOv39BJ8/1ThCQYUNXirZUmHQ0SFtS4/zOJIM5nZwuuqAEAoFgITGrTM3/+l//i9tuu40vfOELh93/iU98gmuuuWZOFicQzBU53WQwX+bARJmLl6cZLVaIh/yPf01EXJv6Xao4tCRCtKdChNUAd963oz4/Kqv7pnzNMY2Sbom6vEAgECwgZpWp2b59O+973/sOu//mm2/mlVdeOeFFCQRzTU638ADDdtmf0QkFZEKqQmdDGE1VAIhp/td4VVgYDarced8OPnrtaqIhpb4tz4P+XBlHdEEJBALBgmJWQU1zczPPPffcYfc/99xztLQcuR1WIJgvnEl6eMfz6M8a7MvoPL1vnMaoymUrmxjJVyibDsGAREILUDIdbnp9N7IEe0ZLjOQrTOgmI4UKe0dLmK7LqJgDJRAIBAuGWZWfPvCBD/Cnf/qn7Nmzh0svvRSArVu3cuedd/LRj350ThcoEMwFR2rxM2yX0UKZz739HL543w4+dPUqxoombUmNwZxBVzrMQM6ouxBfudoP2qNBBdP2qMjCbFIgEAgWCrMKaj71qU8Rj8f58pe/zO233w5Ae3s7n/nMZ/jwhz88pwsUCOYCGWiOacRCKnnDpjURYDhvsOW1UXqaoriux+fffi65soUT8tg9WmJJUsPxqLsQ17xsap1QJdPhubzBJvwOK4FAIBDML7MqP0mSxG233caBAwfI5XLkcjkOHDjARz7yESRhtypYgEiSxON7MwzljXoJaSRvcNs1q/n+Y/twPd+srysdJRlRCQZkokGFsumwrj3JaGH6MpPneQzmDfrH9VP8igQCgUBwKCc0H3xkZISdO3cCsGbNGpqbm+dkUQLBXDKSNxjKlw+73wMmShX+6MIuDPtgGWlpQwTP9dAtG930XYhbE6Ejugx7nofpuBwY11naeHo7tQoEAsFCZlaZmkKhwLve9S7a29t54xvfyBvf+Eba29v54z/+Y3K53FyvUSA4IfSjjDwA6EyH0U3nkPuiRIMqiXCAiu2iBRVcD7a8Nuo/3hgmrCqc15miOaYhAf3ZMjuHCsK/RiAQCOaJWQU173//+3niiSf4xS9+QTabJZvNcs899/D000/zZ3/2Z3O9RoHghHCP8biERCqsHnb/0sYIsWCAVFhF8iS+/9g+bt28mh88sZ/7Xx5GN232Z3SGCgayLKGbDv3ZMve+NMRg9vDMkEAgEAhOLrOa/RSNRrn//vvZtGnTlPu3bNnCm9/8Zkql0pwtcC4Rs5/OTPaNFnE9KFsOecMmrvki4R8908e7L1lGa0IjHQ0e0UivL1MiX7EZyhn84In9vPeSHoKqVB+UF9cCFCsWHckwRdMhX7b8gXlh9ZhDNwWCM5GcbjJWNMkb/r7SdJT9TyCAkzz7KZ1Ok0wmD7s/mUzS0NAwm00KBCcNSZJ4fM9YvWupbDl1kfBXH9jJ/3ftmqMeUDvTUZ7aO05LIsSFyxroaNR4Ys/4lO0N58o0xzUyhQqJiIrluPSN6xQMiyUJTRywBYIqA9kyn/jRC2zZNVa/7/JVTXzhHevFRYDghJlV+emTn/wkH/3oRxkaGqrfNzQ0xMc+9jE+9alPzdniBIIT5XhFwkciFVEpGg7Xnr2EsUJl2u2NFQy6GiN88+FdjBYqREIK4yWLA9kyByZEd5RAkNPNwwIagEdeG+MTP35B6NEEJ8ysMjXf/OY32bVrF11dXXR1dQHQ29tLKBRidHSUb3/72/XnPvvss3OzUoFgFsxEJDxeso65nZZ4CNN2UZCQJVjeHJ1SfooEZWTJdyu+dfNq7rxvO+d1prh6TQvBgExOtxjMjpOKqLTEQyJzIzgjGSlUDgtoamx5bYyRQkXsG4ITYlZBzfXXXz/Hyzg9ODChUzBs8mWLZFglpgVY2iBafOeT2YqEDyUZCVKo2Fi2S2MsNG356Q3LGwG4877tdbO+gmHzlQderbsRly2HHUMFGiJBWhMiuBGcWWT1o19AZMvHvsAQCI7GrIKaT3/603O9jkXLaLaM4bh1gWgyrNKR1AgBpusxminRLNxm541jOQmDn4WZCUsbIvSNlShZDuvakhiWQ0tcASTGCgZjhQptiTDr2pMM5vyS14Pbh+sBzo7BPGvaEoSDCuO6SdlyaKrYdIjAV3CGEJk0GHbax4NHf1wgOBaz0tQIfEYzJQzbpT9XxnZdXA9s1+NArozhQdB1KXswKvQU88axnIS9qpPwTPHwryYVxf+/JEmUTIueJj8wcTyvatan0ZrQprgRdzZG+NqDr/KbnSNEggqSBAcmhLeN4MxBCyhsXJme9rGNK9NoARHUCE6MOQ1q3vOe93DVVVfN5Sbr3HHHHbz+9a8nHo/T0tLC9ddfX3czng8GsmUsoOK6fP2hXfzu17dy412P89avP8o3HtpFxXWxZJmBfBnDPe6uecEcMFci4Ro53cT2pi9opWMh+ifKuB5UbLd+29CZYk1bgt2jpfoMqTcsazxETGwKMbHgjECW4JYrVx4W2GxcmeaWK1chS4gAX3BCnNCYhEPp6OhAlk9O8ue3v/0tH/zgB3n961+Pbdv81V/9Fddeey2vvPIK0eipL+/kyhaRoMKnf/4yW3dlpjz26K4Mn/n5y/z928/1xaSmmOQ8H8yVSLhGqWwhSxKOC33jZTRVYevuMbYP5Lj9LWs5ryuFYTkkwyqG5b/nFdsPgmpZm8FcmS2vjXLbNat5rneC5niIaEihYNjYjofnemI4puC0RZF8of3vnNvGzRt7qNguoYDMcN5AlvygR4iFBSfCnAY1n//85+dyc1O47777pnz/ve99j5aWFp555hkuv/zyk/Z7j0S+Kmg7NKCp8eiuDLrpUDQcFNkhp5tiRz3FzJVIuIYDZHUbRZLobAgDEl0NYS7oauCOe7fzN289G9206GoI8+iuMTygOx1Frzj1rA3AH13YxUSpUi9H1UTEAAM5A91yWSJExILTEAloiofYM1qa9v6SaVMyj7XnCgRHZlZplZdeeumIj/3sZz+b7VqOi9qMqcbGxlPy+w4lEVYpHEOpXzAsYppCXFMZK4qU6qmmJhI+b2mKSDBAV2MEz/PY8tootYrgTEXC/eM6j+4aI1OqMK6bjBZNXuzP0p2OEAnKrO9MoVsOqbBKZzrKplXNrGyJ0RhR0VSFUECul6SWNoanlKMu7mnkpf4co4UKmZIpRi0ITlsSEZWJkklPc5SWRIiGSJCWRIie5ijjxQoPbB8RYmHBCTGroOZNb3oTe/fuPez+H//4x7zzne884UUdC9d1ufXWW9m4cSPnnHPOEZ9XqVTI5/NTbnNFMqwSP8ZVflxTKVVsYkGFgiFaFU81cyUSzukmfRM6jxxhmOVQzuDK1S0UDKseJHU2RljdGicWDJCOqozkKyTDqh/cWO4UEfF0gzLXL01SthyhLxCcViQjQZpjGntHS4zkK/5+ma+wZ7REseLwfF9WiIUFJ8SsB1pu3rx5iqPwf/7nf/Lud7+b733ve3O1tiPywQ9+kJdeeon/+I//OOrz7rjjDpLJZP3W2dk5Z2toT4VJBBU2HUHJv2llmkRQoSMZRnM9oqE5rfQJjsFcioSzusU9LwzwV9etpT0VRq84pCIqjuvx9Yde5bzOBgKyH8RODpKSkSCdTVE601EuX9VEYzTISN6gZDpTRMSTB2U+tGOEuKYQDMiUTYdXh4u8Niy6owSnD67ncX5nCk09GLwM5Az+/fF9fOCyFUjSPC5OsOiZ1UBLgA996EP85je/4ZFHHuG+++7j/e9/P//+7//OO97xjrle4xRuueUW/vu//5tHHnmEnp6eoz63UqlQqRy0tM/n83R2ds7pQMv9mRJ//dMXeXSStmbTyjR///ZziQC4BkVCyJJEd5MQgJ4q9o0WGS4Y7B4t1U3yNFVhKFdmRXOUpniI8ZLF65cdu3y5cziHpgR4rm+C8zpTlC23PrQyFlT43ta9/PEly4iEArQmtCNuJ6eb5HQL3Xbonyj7paiGMKOFCj94Yn/dz8b14K4te1jXnmRDZ4qK7dIQUelqjAhPG8GiZ89okdFD9s2aWHhFc4zmeOioA2YFZyYndaAlwNe//nXe+c53cvHFF9Pf388Pf/hDfu/3fm+2mzsmnufxoQ99iJ/+9Kc8/PDDxwxoAEKhEKHQzDQTsyXoOtzx9nMpmg6FskW8eqIrV3S29umsaI7RlpDIlk1ABDWnClmWSISDrGiWqjV6iYd2DvN8X5aepuXHJRKOBAKMFcu8rquBTMnCsByiIQXb8Xh8T4Z3X9pDxXWOGtCAn7lJRoIM5w229WbpaoygVxxaEqFpDftGCwbN1XKWbjqMFU08D5Y2isBGsHg5ViLGxWM4LzqgBLNjxkHNz3/+88Puu+GGG9iyZQs33ngjkiTVn/O2t71t7lZY5YMf/CB33303//3f/008Hq+XvpLJJOHw/E12PVC0aYxJBAMSu0eLtEy68qgp+i3PJRqaeZeN4MQYzJbZumus/l6UTD9Dc3FPI+s7Uty1ZQ9//ZZ1MxYJ265HKqrxhV9u54YLOmlJhCgaDolwgAu6GxkrlmmJz/wz2JrQuOKsZrJli4rlUjScemcUwHmdKSJBud4ddeGyBq5ZtwTL9ujPlilWbBqiwWMGUQLBQkQ+RlRjmA5l0QElmCUzLj/N1H9GkiQcZ+59WaQjFFq/+93v8t73vndG25hp+up4eHkgh+d5lE0bx6M+5DCmKZQqfvtvTAvQngyLK49TQE432TlUYNdocdqy0/6MTu9EmevOWcLZ7ckZbXP3SJGv/GoHt167mkyxMmWQZbFi0RbX8IBlzbHjXmu+bJE3bPaPHzTeW9oQ5qX+HA9uH+a9l/TQ3qDx+Xu3TylHpSIqnamw8LQRLDr2jxUZLlTYNVKctvz0+N4Mm9e2znj/FJwZzPT8PWOhsOu6M7qdjIAG/PLTdLeZBjQnCy2g8MpAHteDPdMo+j0gFgyIgOYUkdMtPI4cp69rT7ChM4V+HIaIhu1w0xu6UeWDxntly+G+l4e465E9WJ6HMgt1YzISpDMdJRlW651RoYC/S9a6o4KqxOfv3c5NF3Wze6QA+B1SEhL5ik3fuHAhFiwuxkomrfHQtGUo3fQ7oCKq6IASzA7RknOCSBJ0p6fXOEhItMY1jnKOFcwxjuchS7C8OToloxIJysgSaEHFz3Qch+meYTp0NEb465+9OMVscePKNH+yscc33vvds2e95qVV/5yaYV8sFKh3R0VDAda1J/nxM33cunk1d963nfM6U1y9poVgQCZftnhq7zipiEpLXBj2CRY+mqrQmylzfmeKcd2qu24P5Awe3D7MBy5bMaUzSiA4HmYd1Pz617/m17/+NSMjI7ju1Prnv/7rv57wwhYLtauN/Rmdczr8dKluOmgBhY5UGM/zyJQtOoVI+JQgAc1xjf6sMe0oA6UqEJ6pngYgHQvyuXteZkNXQ93aXVMVnu2d4O4n9rOuPXlcmZ/p6ExH2SRJDObKxDWVYsWmYh/U22zoTHHnfdvrHVIFw+YrD7xaL0mNFiuMFSuiQ0qw4AkHFO5+aj+3XbOa3kyprn3b0JmiI6nRkdIomUcfcSIQHIlZBTV/+7d/y2c/+1kuvPBC2trajqh3ORNQqqo32/UYLVTq9eE9o0VWNMeIJDVx1XEKkSWJR3ePTRHRtie1KaMMutOR48po2K7HOy9eVu9OOnS7EsyJuWJnY4SEFiBfthgp+AFKTFOY0E06G8OiQ0pwWhCQJd59yTK++sBOfn+y8F4L0JOOUjItioYQCgtmx6yCmm9961t873vf413vetdcr2fREZClo84yUTgY+AhOLjndnNZwD5gyymBt0/GJxD1AU2V+8eLgYeWnW65cSSSoEJojF9Ra2/cViky2bJErmyTDquiQEpw2aEEFRZa4bFUz4GvUQgGZvWPFKUJhgWA2zCqoMU2TSy+9dK7XsihRbRdbkumZpOGIaQrRkEJQlgi6OhV5/lrOzyRyuoV0FD3N1WtaZpVRCUgSd23ZM235qdYeHtPmVp7WlgoTCSrEVAUHKFVsJia5Cl+5uuWoHVKZkklKNzEtR3RICRYUecOiNa6xe6R42GM1ofDvrm+fh5UJTgdmPSbh7rvvnuu1LEoOlC3wdDqSYQKyjCJBQJbpSIbxXJ3bf7FPjEg4RXieR3Ncm7ZDqSEaIhxUSGjH7xdk2A43XdTNtt4J3vdvT/MXP3iWm7/3FNt6J7jpom5M59jGe7OhNmahIaKS0AIz6pB6ZSDHtr4soYBMVrfoy5ZFh5RgQTGhW9iee9RRCarIbgtmyazOtoZh8J3vfIcHH3yQ9evXo6pTTxRf+cpX5mRxi4GEpvLmrz/BP964ge9u3XtYeeLTv3s2BcMSZYBTgCRJbD2GniYWPf4ykSxLjOQNbt7Ywzsv6q5naf710b3AXv7mrevm8FUcTq0kBRy1Q+ru6qiF0YJBayJESFUwLZfBnIFuOixJiO4owfwTDSrc//IQbzp7ybRC4ZZECNcVLaOC2TGroOaFF17g/PPPB+Cll16a8tiZJhpuigW5oLuBD/9wGzdv6qmXJ2pmUr98aZBLlzexfTBPLKigAJIs0SY6VOaUnG5SMm2601FyZaseeLwykOMDly2v62lmM38rKE+vp/nHGzfw4R9uY3bT046fY3VIqYpEJCjTnY7Uu6PO60xx5eoWKrbDjqECDZEgrSK4Ecwj0WCAp/dNcE5batqyvYLvZdPdPN8rFSxGZhXU/OY3v5nrdSxakpEgf/u2s/nUf7/ENx7aVb+/5mHyuV9sZ/PaVlJB5eAf2/UYzUwVFiNLNItAZ9bkdIttfdlpszR3bdnDrZvPmpWeJqeb/M1/vzQloAHq39+8qeeE27mPh6N1SNV0NnCwOyoSlHmpP1d3bi2ZDs/0TnDFWc20pYTWS3DqSUVU/vTyFXznkd1TXLJdT6UxEuTelwd541kt871MwSJFiD1OkOG8AcDvnNs2JUuzrS/Lh3+4jQ1dKbSAQsl1CEsKQZg60c2rfj850FEVmkW5asYcq+vpvGrX0Gz0NGNFk2d6s9xy1cr6wXdy+enmjT0kj8PIby44UocUUA/q1rUnGS0YdDZGeHD7cD1jA376P1u2kGVJlEUFp5xkJEhbQuOata1TZuXtz5QwbZen903w5rPb5nuZgkXKjIOaG264ge9973skEgluuOGGoz73Jz/5yQkvbLEwXjJRAxI9TVG+8Ztd07T8rkKSICEpmIAtwRRbKenglwCgAFgOo5kSzaJrZUbMpOupVHFobTr+E3ixYtX1Uodm4v7xxg0okkRTbH5KOYd2SA3njbo764bOFM3xEF978FXedfEyNFXmaw++WncjDigSY4UKvRlduBELTjkyHNVROHCGyRgEc8eMg5pkMlnXyySTYtAYwIEJnULZIhJSkKXDszXDeQNZ8gMWQwIXf2cuHqFcEQsqWPjPV4HRCV2UpGZArevpSC7CkgSqIs8qK5EKB/ni/TuPWH763O+dM6/BQC1rk9NNKrZDseKHzLUTRc2wb3I5qlSxeeHAwZJUoWLz9H5RkhKcOmzPI6jKRxQKO55HTjdFoC04bmYc1Hz3u9+d9v9nMgXDJh5W+dUrQ1zc0zjtcyQJTMfFmJSeKZSr2g6Jg3OhDrkwiQUVpGpJSmRsjs5Mup6aErMrEVmuO60/zb8+6ne62QukS6N28H+2N4vneXSno+iVg4Z9teAmIEtTSlLXrG0hEgzQltToG9fJGVZVTCzKUoKTy3ixMq1QeLxYoSEWZKRQEUGN4LgRmpoTIF+2WJLUeKEvy/qO1GGPS8CShEapYlOoRTUSxI+gwThUyCpJgKowPKHTKjI20zJTF+HuyOwCQ0mS2NY7MW3p6cM/3EapsnBm1CQjQa44q5m+CZ14KEDF9hivGvbVgpvJJalYSCYYUPjsPa/UNTem7bJvrERWN1mS0MRJRXBSkCVwPdgzWqpnDHXTz26vaI5hmA6GJUYlCI6fGQc1GzZsmHG79rPPPjvrBS0mEmGVAHD7W9Zyx73bWduerF/haqrCJSuaGCsapCKhaoTiEwv6XimTEzWHUjAsJCQ87+DzBYeT062jDkGfrYuwv22Tzxyj8yk+C/HxyaSms8nrFrEQ6KZN2XLq5Sg4mLVZ3hzl8/ceHJK5YzDPmrYE4aDChG5hWC5NFVsMyBScFI52Pvn1jhGuEaMSBLNgxkHN9ddffxKXsTiJawECrkdIlvnA5cvradSWhEKpYuN6HrGwSlCWUIMKLr4Q+EjzoaVq8FI7SbueVz8hH5jQWSpOLofheB7yUUTCWlAhIM/KOJtMyeS8rgbee4TS0wevWDlvIuGjMdmsT5Iktrw2Slc6imE5U0pSNdO+0YJBdzpCZ2OEO+/bwbbeLLdctYJr1i0hZ9j078mQiKiiLCWYM8ZKJs2x0FFHJVx/Xsc8rEyw2JlxUPPpT3/6uDf+wx/+kLe97W1Eo6enJmRpQ4TRTIkA0JEMUzQdFNkhIMu0J8OYjkNYUepBjIUvAJ4Ol6nBjhRUsFwPWZLqgY0Qzh2OBEcVCStIxKOzy6Z4cNTSU0iVF/z7sbQxwuWrmslXbJ7rnWBtW7JekqqZ9jXHQ7zUn+MXLw6yrTfLt955wWGzpMZKJqmImCUlmBs0VeGXLw9y5Vkt03ZA/enlKwiLDLVgFszuEnaG/Nmf/RnDw8Mn81fMO83pKAFFQsavMElIuJ6H7XqEFYXada0rS7Sno1RkiTHTYW/eYMx0MKqPH/pGhFwDTZaIBRXimkrBsBgvmQimosgS/VnjMBfhGy/q5o57tyNLs/NiOTChY9ouH75qFb/8yGVs+dgVfOPG9WzrzfLdrXu5eVMPqfDCDmhqdDRGaE9qbFzRhKbKpKozpGKaUj+ZtCY0tu7KcPOmnsNmSb00kGNpQ5hYKMBAzmDnUIGcLj6LgtkTDig8vW+CoXyF/ZkSoYBc74C6Zm0rbQmNXHl2ZWPBmc1JFQp7p8o/fp45nrbrySWkAxM6BcNm0LCIayqxYDUIcnUMOYKG/wbVylK6deqcaxcD/eM6W3ZN3/X074/vY117clZ/s/2ZEn/10xenaGk2rUzzuevP5b/efwF/+H+eWbClpyMxufU7GlR4dNcY0ZBCMqyiV5wp/jaHzpKq6W3WtSdojAUxLZedw0VSYVWMXBDMioAs8YHLlnPXlj2sO0SLeH5nAyXTolQRQmHB8XNSMzWCo7O0IcLatgTt1R16sJa9qQY0NUL4YmG9IoKaGjndpD87/fTpmovwhs7UcYuED0wT0AA8uivDJ3/2IslohD974/JFUXqajmQkSGc6yuWrmgnIEh0pDU1V6pO/J8+SqultgPo8qTvu3c4vXx6iYFjsGi3yymCe/gkxBVxwfCQjKoossXlta92pu+YqnDcsHtg+QiQkyk+C40e0dC8AQgDVbEz9JBxUpgQ2QSCmiberxkxchHvHy3QcR3fSQLZMwXQOC2hqPLorQ9F0uHJ1C9Hg4n4vOhojxLQABd0iHVXZPphn48p0vSw1oZtT9DZwcJ7UoVPA+7MGxYqYAi6YOclIkNa4dlSh8O+ub5+HlQkWO4v7yHyaEAyrULamD2xcD0uWUAFNFYm1GjNxEU6GVRqiMz/J5soW+WPU8QuGRTioLKrS05GY3CV1uSTR0xxlz2ixXpaqaRpqpYHzOlNiCrhgzpjJqATRHCE4XkRQswBIRoKMli0kIBSQcUMBioaNLEFAVfyOKc9DkyQOZEosFd0nyLJE3rCRJYmuxgjDeYPdI4W6QPhv3no2XQ3h4xIJ58sWiWMMp4xrKsWKfdodaGuZm/aEhud5eFUPkcl6GzEFXDCXOMcYlWB5rnAVFhw3JzWo6e7uRlUXljnZQmS0qkkI4ndJVSQJDw/XAwf/TbIliQCQNR36xnU6G89cz5reTIlHqwLhiu1SthxG8ga3XbOarz6wk7VVgfDatsRxbTcR9sXam1ameXSaEtSmlWliQYWAfHoO25ucucnpJooEmZJV19vA0aeAX72mhZCq0BoPcWCiTKFi0yoGZQqOgCxJjBaMI45KCAcVysJVWHCczLqekc1m+T//5/9w++23Mz4+DvhOwv39/fXnvPTSS3R2dp74Kk93Js0POvR06VVvteizYFgUKzZ9mdIZ2VY7kjcYzB0+FsEDJkoV/ujCrlkJhMEvV2nA564/l00r01Me27Qyzd+//VxU16MlfiT7xNOHmqC4KRZkJF9hOG9QNv2sTe2Kek1bgru27OFdFy/j4p7GupD4wR3DhFQZw/JLUq+KFnDBNCQjKh4Se0ZLjOQrTOgmI/kKe0ZLuJ7vKhwRXjWC42RWmZoXXniBzZs3k0wm2bdvHx/4wAdobGzkJz/5Cb29vXz/+9+f63WetozmDQwPtGo0c2hQ4wI2B0374ppKoWzhuh4SYJoOzWdQmr9iOSTCQVY0S9UDnsRDO4d5vi9LT9NyOtNhdg4Vj0sgXKM9FWYoUyIK3PH2cymaDoWyRTw8qd1eVc6ozINv3tdEf65cL73B4VPAQZSkBMfHTMTCbz1XiIUFx8esMjUf/ehHee9738trr72Gph3ULLzlLW/hkUcembPFnQkYlkP/pIGMQZhiuKebDpMTsLGgQjysUjIdCqaDbruMZko8u3+cHUN5hvPGYb/jdGEwW+bRXWMMZMtkSiajRZMX+7Nc3NPIuy5exl1b9oAnHbdAeDJL0lEIyAeDy0lRZjCsnlEBZI2OxgirW+PEggojBT9rU/O32dCZojWh0ZrQ6iUp1/MDnJcGcnQ1hulsDLO+I8mBiTKvDousjeAgnudxfmcKTT2YkRnIGfz74/v4wGUrkCXE50VwXMwqU/PUU0/x7W9/+7D7Ozo6GBoaOuFFnUkUTYdoqPo2eByeqjmEsmMTVhVcV6FgWHznt7v46DWrWRIL+dmcis1ApkT7aSYmzukmWd2iKx09zD24p2k5owWDde1JDNs5boHwoZyJgcuxqOltrlDkaaeAA/UW8NoU8EhQpmDY/NNvdvH7F3TSkgiRKZpYjkuhYotZZgJkSSJvWOzPHJzWvaEzRXtSQ5b8ad5CLCw4HmaVqQmFQuTz+cPuf/XVV2lubj7hRZ1J5MsWRWPmpnphOcDzfVlCqkxcU3nfphUUq9kcC19QrHp+Wet0IqdbbOubwJjkENye1OoZmjVtCTZ0ptBNMZvoZNKWClezNgHSUbU+cqFmcw8HS1K7R0t8/7F93Lp5NT94Yj/3vzyMbtrsz+j0juv0ZUrz/GoE840ENMVDh13L1e4vmTZZMS5BcBzMKlPztre9jc9+9rP813/9F+BPAu7t7eUTn/gE73jHO+Z0gac7ibCK7R4sMJlAyXIoGjbRUIDQ5FIIMFI0WJIMM16q0JoIUzYd8lVRbENQwZJ8DY58Go1UyOkmumWzri2JYTm0xH0tzVjBqLsHg6/zSB2jJVtw4kw3BdwDutPRKVPAAX7/gk7uvG/7tKZ9g/kKuuUK074zmERE5bWRwhE7oP5nT4bNa1vne5mCRcSsMjVf/vKXKRaLtLS0UC6XeeMb38jKlSuJx+P8/d///Vyv8bQmrgUoVWxwD1rNBxWZSMgfi2A5bv1NGrct9oyWaIqHaIppKEDBsOv6Gwu/nFU0HWyg/zS4Es7pJkN5g1zZRpEhGgrw0M4Rvvrgznpb+9VrWtBNh1RYPSM6kxYStSngK1tiNEZUNFWpd0hVbJeWROgw075ah5SmynXTPtEhdWaSjARpjmnsnaYDqljxxcJaQHRACWaO5J3A1MmtW7fy/PPPUywWed3rXsfmzZvncm1zTj6fJ5lMksvlSCSOz8PkZNKXKVFxXJKSQUWOUDAdCocMuRwuGyiKSliVGStWaI1r6I6DbXskQgGKpp+ZKVRTtfGwihaQUWVp0Zr1DWbLPLxzlJZEiIrtoqkKQ7kyK5qj6KbLvz++j81rW3l9TyMlw6E5HqRD6DTmhZxuktctkKBvoky5mimMBANEQ8phpn2aKteHGdZm/zREVLoaI+I9PMPYO1rEsBzGdYtc2fdF2taX5ZWBHB+4bAWtiRDLm2PzvUzBPDPT8/cJme9t3LiRjRs3Ar5vjWB2dKajDEzo6G4EfVJAkwgqeK5DARlJ9l2GJSnAkrjGiwM5ljVFiagKslsmEgwznDeIV8svBcMCTcXAD5o0VaH5BMSzp5qcbtI/odPTHJl2tlNNGNya0DAtl6aYCGjmkyOVpM5bmsLxvCmmfYO5spgjJajjwVHFwgLB8TCr8tOdd97Jf/7nf9a//8M//EPS6TQdHR08//zzc7a4M4n2hgjd6Shr2xK8oSfN2rYEniRxoGBRMm3yZRstKJPVTQbzBuvakpRNm7As4cphMkWjntmZ3BJeMCyKpoNhORxYROWogm7RFA/huNA37l/53/fyEHc9soeGaIhzOhL1K3zdclh6BjssLzQml6TCqnKYaV9rQhMlKUGdY8UtEqKtWzBzZhXUfOtb36o7BT/wwAM88MAD/PKXv+S6667jYx/72JwucDKPPPIIv/u7v0t7ezuSJPGzn/3spP2uhcDSxghdSY2gIhOQJWQkWuIaLfEQzx3I0hzTMF0PPI9wUCUe9OdEPbVnhHg1sKkFN0XToWDa9GdKDFVvA5nSguySyukmJdthOF8hoQXobIjwYr+fjq7NdooEA1Rsl1BAFuLgBUjN2yYoS6QiUzukKrbLlatb2D1aYvdoqe5K/IZljXztwVf5zc4RwkEFQwQ3ZwSKdPSwRpZgrCjef8HMmFVQMzQ0VA9q7rnnHv7wD/+Qa6+9lo9//OM89dRTc7rAyZRKJc477zz+6Z/+6aT9joVGezpKQlNJV6dCZ4omZctlZXOMx/dk8CSJZ/uyxIIKIeB/9oxwwfIWyq49NWtTtvCQyJsOFlDxfOMroxroLBQGs2XufXGIAxPTG+zd/cR+1rYnKVsuybDKSKEixMELlGQkyNKmKEsS2hTTvtosqcmmfYO58pSRCzsG88gSNMaCWI7LzuGiCG5OUzzPO2Zb92zGngjOTGalqWloaKCvr4/Ozk7uu+8+Pve5zwH+h9NxTl4r8XXXXcd111130ra/UGlLhRnOlqnYLlEtQK5q3X/O0iRjRYMNXQ2UTIMiKq/raUbxfD8bBSg4NtGg/zbnyxa1i6Lneie4dGUTumkjIdGbKfnDCOdRd5PTTfrGdTym167XdDS12U6N0SArmqJCe7HASUaCXHFWc92077m+ErFQoO5rU2sBrzkSd6cj9bLUVx54tf6ejxUrZEoVISY+zTBcl4JuHbWtW4xLEMyUWQU1N9xwAzfddBOrVq0ik8nUA41t27axcuXKOV3giVCpVKhUKvXvpzMMXCy0psJoQYWhvIEsSXieh6YqJIIBSo5D3oC45qdyHddDkSTcanAzWizTHAvXDYsLhkVLQkM3Hbzq9VHJdHjhQJZzO1JYnkM8FDzlAU5Ot44Y0ACsa0+QjvmdUO2aSntSEwHNIqEtFSYSVMjrFpeuaEK3nMPmSNUciSd3St10UTc/fqaPC7saOKs1RkWIiU87XNcjqCq81p+jpSoU1k2Z4bxBWzLMiwdy/MEFYjCyYGbMKqj56le/yrJly+jr6+OLX/wisZjfbjc4OMhf/MVfzOkCT4Q77riDv/3bv53vZcwZkztMJjOcN3Ac6inaSFBBAkqujSopNMfCvFTrlqpmbcaKZrUkRT17c97SFEP5Mm2JMP/5xD5+73WddJ/KdnCJow6r1IK+B0oyrNIYnf5vIVi4TP78DucNnuvL4nke3ekohuXUg5vJnVI/fqaP265ZTaZY4fP3bue8zhRXr2lBlqnOkiqSivj+ROLzsDgJKQr/+Osd/PkVKykYdv1zMJAz+PX2YT711rOrxzYxvkRwbE7Ip2Y+kSSJn/70p1x//fVHfM50mZrOzs4F51MzV/RP6OQNu94SHgkqyMB4ySAV0XA9j6As4QKvjhRpT4UPGzdVMEzSUY2gIvGDx/fzxxd3nxKfm/4Jnf0Znewhc50+cNlyDMv3pPnrt6xjKG/Q1RAWoxBOAwaz5UklqSxd6SiKJNXnSdW0N8N5Y8oEcIDdowfbfzVVYThviCngi5TesRL9VU3VZN+iZFilMRLEw6VYcXhDT3q+lyqYR06JT80rr7xCb28vpjlVvPe2t73tRDY7Z4RCIUKhM0dE2tEQIaabDEmQL9u4nkdYVWiMavUSVAAYLJUZyRusbImhm/6ATEmSGMoZpGMhDMvBdCTeeXE3BdOhL1MiEVZP2pXwwLhOX1YnHg4gSRJxLcCmlWne0N3IXVv2sHlt68FhlY2RupOwYHEzXUmqYrn1YKZiu3Q2+kFKTUwckCU6GyM8uH24nrUJqQqt8RAHJsoUKjatImuzqEhGVIYKBpvXttYD1VBAZn+mRECWeHxvhmvXLZnvZQoWCbMKavbs2cPb3/52XnzxRaSqvgP87AlwUsXCgqNTS/EfyJQomA5jxQpxTaU5FkZxPcqA5UhsXNmE4oEWUFCq72EirFKxXEqmA1Vty+Sug0LZIjTHJn453US3Hb7+0C627srU79+0Ms1n3nY2Fy5rqHfJ6KbD2e3JOfvdgvlnckkqp5vkyxbbB/N4+GWpouHU/W2Aw6aAlyo2LxzI1U+GhYrNM/snRNZmEZGMBFkS19g9UjzsMd10eKEvy/XndczDygSLkVkFNR/5yEfo6enh17/+NT09PTz55JNkMhn+8i//ki996UtzvcY6xWKRXbt21b/fu3cvzz33HI2NjXR1dZ2037sYWZqOMpw3kKA+8DKiKuB5tCX8uVGDJYNUJIjtQqZk0BwPM5yvEA7KBGSZQrXLqjBpSq6LR1+mRACIzEH2plC2eHb/BLdtPosPXekRDR3U0txx73b+11vW8tqwf7ATfjSnN7UA53JJoj9XJh4K4Hqgmwd1FjB91qZWtjAsh+50hGzZIhJURMZmkeB6HpesSNOfNQ7T1Nz+lnW4i1MlIZgHZqWpaWpq4qGHHmL9+vUkk0mefPJJVq9ezUMPPcRf/uVfsm3btpOxVh5++GGuvPLKw+5/z3vew/e+971j/vxCnf10KhjMlLCBvGFTMh2iQYWQKjNeqtAU01BlidGCQUgNsGMozwXdDZQtl0hQqY9uiGmq7+5ZNmlPhrFdj6Ain5Cbb1+mRN6wyRs2cS3AcN7gR8/08e5LlmFYLkuSGgPZMmFV4ez2hDhJnSFMniX16K4xuqpi4mgwQMn0u6YmZ21GCwZr2vx9Wjcdv+waUYX2apGwZ7RIpmjgeExp6y5VbBRJIh0T85/OdE6qpsZxHOLxOOAHOAMDA6xevZru7m527tw5uxXPgCuuuIJFqmteGHgQUHzNSsGwkGWV1niYgAQKEA6pKBKc39XAWNGgNR5Gt6f63MiSRDQUoGDYFCoW4JeugopM63Gm+/syJXonyuSq4uCtu8fYPpDj429ey9ce3Mllq5ppS2qM5A0uP6tZBDRnEJPLUhuBUsXmub4Sa9uSdSExUB+30NkY4WsPvsp5nSmuXN0C+Ff6uuWK1u9FguvBnkkC8Fpb9woRzAiOg1kFNeeccw7PP/88PT09XHTRRXzxi18kGAzyne98h+XLl8/1GgVzQEBVcEwbVfGt6mt2MI7noSAxUPKFxMOFMo1RjdZ4mKAHUiDAcweynLc0hQd4rkfe8K+UY5r/8cmULJLhAL2ZEskZlqT6xnW27Bqb4oXTntS4oKuBL963nZsu6gb8ZV6+qlmYrZ3BdKWjjOYNLl3RRNlySIVVypaDXnG4cnULL/XnpnRH7RjMs6YtQTioMKGbGJZDU8UWnyGB4AxgVkHNJz/5SUol31r/s5/9LG9961u57LLLSKfTUwZdChYOzQmN/kyJimXjIfkBClCxHaSA72Vjug7Ncb9DSgXKnsd4qcL6pSkm9DJqQEULKrjViKho+IJwSYKgJfN83wSbVjZRNh2WHCVrk9NNhnM6yyc5iNYmcCsSrO9M0ZII0TdeRjdt1radWaVCweHUxOk53SQaVHh01xhr23zReG3UQs2NuJa1qelsxksmumnjeYjBpwLBac6sgpo3velN9f+vXLmSHTt2MD4+TkNDQ70DSrDw6EhHCeQNxksmkuT700SCAVRZor0hQn+mRMFyKJRtIkGFcFAhHdPwXI9UOMxo0UCS/FJAqeLQkvDb5T3voEtx0XTIlQ08z6PtCFfGhbJFLBwkp1vgQSwU4Nc7hnmhL8vtb1nLNWtbyJWd6rBKUTYQHGSymLhQscmVrXp3VM2NuJa1GS0YtCZCaEEFyZPIGRaDe8eFWZ9AcBpzQj41AH19fQD1AZeChU2tPXo6OtJRDkzo9SBFliWUoIIiwzO9E5zf2YDreTTFZb7/Pzt596XLAD8wimsqmZLvUhwNKeQrNoFMieZDhJqD2TJbdo3V7dBLpsJQrszFPY2s70hxx73b+dRb1+F5EvsyJS7sbjjZfxLBIqSjMUJO94PzYsWe4kZc09l0pyPVANxmf0ZnTVuCkCqTKZnopihJCQSnI7Oa0m3bNp/61KdIJpMsW7aMZcuWkUwm+eQnP4lliWmqi5mlDRHWtiVYWj3YD+cNCqbL67oakPE4MF7mK/fv5KPXrqElrqFIEjsH86gBiVBAJh5WKRoO+bJNBRjNlNgxmKd/Qienm2R1i650tO4E+2zvBA9uH8b1/IGVtQnc4aDClUIcLDgKyUiwPgE8GVbRK76nzZWrW9g9WmL3aIn9GR2AzsYI33x4F6OFCnFNIajI5A2bp/eNs3u0KKZ/CwSnCbPK1HzoQx/iJz/5CV/84he55JJLAHjsscf4zGc+QyaT4Zvf/OacLlJw6mlPhWmv6mKGqyWrgmHRlAjxiTevxfZcnuvN0tEQ4XXLGnm+d4KK7bKiOYqtKchIFEwHggrpoMJAroQbi7B7tEA4ePBjVxMH37VlD7duPot0LETBsGhvjYuARnBMahPAs2VrihtxLRtZK0lteW2UWzev5s6qCP3uJ/bXNTcjhQojEVVM/xYITgNmFdTcfffd/Md//Ed9OjfA+vXr6ezs5MYbbxRBzWlGrWQ1MKEzoVsMFypEgwrrO1OMlyqMFyt0NERYktB4rm+C1qRGS0xjrFQhFJBxZYklsQi6Z/C6pSm2H+IcGgnKnFd1jK3YLh3ayRvJIDj9qI9bqLoRx0KBKWZ9rQmN37+gk8/e8zIbuhq4+4n9dc1NWzJENOib/BmWy8sDOXTT77ASuptTx7GUmEKpKZgpswpqQqEQy5YtO+z+np4egkFxEDhdaW+IEA2ZDOUN8mUbJEhHNWQJKo7DWNHgnKUpxosVXMkjrvmttzsH87x+WSMBSaPieqxrjrJnosxje8d5ZSBHT9Nyrl7TQrHikAyrNETFZ0hwfEwWEOcrNsWKbztQK0l1NobZuivDzRt7UBWJSFCmpylCSFUYyhvA1CGZBcPmaTFu4ZShHKPB5FiPCwQ1ZqWpueWWW/i7v/u7KROwK5UKf//3f88tt9wyZ4sTLDySkSD5skVzIkhAlqrtsg5BWSEZDfJ87wSNsRAv9GaJBRX0isO5nSmKpkPRdNAtB0eS6GmM8McXLOVv37qOn247QEhV0AIKXQ3hIwqZBYJj0dEYoTEaZKRQYThvoKkKoYBctx+YrLlxPHhizzj7MzquBw9uH+algRxdjWG60mHesKyRcd3kqX3jvDZcELqbk4jfgBA6LCMjAU3xkBiTIJgxM87U3HDDDVO+f/DBB1m6dCnnnXceAM8//zymaXL11VfP7QoFC46YpmJYLpGAzITn4eIxXKgQ0xTaG8KMFytc0N2IBCTCASzbo1idPyVJEmFVISBLSPheOR+6YhWGa5OOBcUEbsEJ05rQuOKsZvomdDRVYiRfYf1SP1CerLmJhgK0JrRph2QWDJvvP7aPP7qwi6WNYSqWy87hIsmwKhyKTwKy5I9p6ZnkXRXTFKIhhfFihda4Rk43xd9dcExmHNQkk1OnI7/jHe+Y8r1o6T5zSIZV8mWLbX1ZNnSlKJkuAdlFRqIlrmE6Dq7nEZAkEqpCb84gUR1GKUlQthzkajo5VzZpiASJqgFhjCaYM+o6G93i0hVpHM9j08o02/qyXLayiYrt1ieAw8EhmTW2vDbKbdesJlOs8OVf7RTBzUnG9TwaYyGe3DNet3vQTZmRvMEblqexPJexoghqBMdmVgMtFytn8kDLueZApoTrwXChPM0QOoeOpIYKVFyPkuUSDymAn04ezFfwqq7E4aBCQPavnuNBhaViAKHgJFCzE/jsPS/zl9euYTBXpiURYiRfmTIkczLDeaMe3OT0ypTPeVwLUKzYLGuMHNU9WzAz9o0WGT3KQMtwUMF2PM7vEr5VZyozPX/PSlMjECxNRwkHZNoSYVriGrIkEZAlVEWmNeHXxkd1AxeIhxRCgAaE8EtScU0lrvmeNgXD8m+mw4FMidFMidGqeFMgmAuSkSDdTVE+f8N6wkGZkUKFUsVmpKq7qdjulFtLIlTvmnrpQJbGWIg9oyVG8hUmdJORQoW9o0VKliO0NnNAxXHxPGnq3zhfYc+of/H06x0jxDV1vpcpWATMaVDzV3/1V9x8881zuUnBAqY5FWZpOkpQlpAlCQ8PrzpU6pneCZIRjaAsoXGwJbO/ZCDhEQsq/k1T6gFOLbAxgLLp0J8pMZgpMTyhz9+LFJxWtCY0eppiXHFWMwFZ4g3LG9FUiVRYJRSQ67daaaolEWJ9V4qRfIUtr40C0NkYJqz6lgaSB6WyMBw9UVzP88dZTPOYbjq8eCBXH6ArEByNOQ1q+vv72bdv31xuUrAIWJqOktAC9cDEsH0HYsn1KNp+kKK7HiXXozGiEVED/sBMx7ewj6h+gFP7+aLpMJAvY7oeNlBxPPozJXFFLJgz2lJhVrXECUqyr+dqCDOSNxiu3hJaoB7cyJ7E9x/bV9fYeB5EQwoFw6ZQsXHm+8WcBgQVhW8+vIuzO5JoqlK/fyBn8P97fB+f/J11FAwRPAqOjdDUCOaUnG6ydzRPKqpRtlwKhkVcU4kEFQL43U4S/n9Mz1fWhGSJkmMTUgLopl+Omqy1yZVNWuIaqiyhShJLhKBYcBLoH9fpz5XxPI/mmMYTezOsX5oCYLRQIRyUcT24a8ueuhtxxXZpiKgsbYiIzr0TYN9okcG8cdjfNhlWaYwECakSmZLF65c1zvdSBfPETM/fIp8nmFMKukUqqtGfNShbDsvTUSqOy3DemBLcuHhkSgYt8TB4oEoKnusRCfpXaVndQpH9a+Bo1SG2AsSCCgOZEhKgyBItwtZeMEd0NEaIaQFyuoXneVy6ognH9ciUTJY2hnly7zgPbh+uj1kAuLCrAU313Yyf3jdOQzRIUzQounSOk0gogCzB5rWtdQPEUEBmf6ZEQJYo5x2aE6H5XqZgETCn5afh4WE++9nPzuUmBYuInG5Ssh2G8xUSWoDWuMb/e3GA/33/DgzTxbJddNOhP29QtFya42FkYLhUJiD71XTP9Q7T2hQNh0LZolD2S1OValnKcDwGMiWGRGlKMEckI0G6mqJ0N8fobooS1wIkwgEqlktrQmNde5K7n9jPTRd188pADtvz+NKvdvIH336Mh18dZd9Yiaf3T/DqkDDrOx5aEhpLEuFpzfcaY0H+8+letIAy3Y8KBFOY0/LT888/z+te9zocZ2FWmUX56eQxmC3z8M5RWhKh+gTuoVyZFc1RdNPl3x/fx7r2JO/Y0EZAVihWy0xxTSUWVMiUyqSjfpCTr5TJGdCRDOMCecOql6IKhkU0FECWJHJlk7ak/zOjRYO2ZERY2gvmnJxusnO4yFjRn2W2rS/Ltt4JNnQ1sK13gm29Wf7xxg18d+tetvVmuXlTDxuqs8w6GyK0Cj+bGbFvtIjr+T5WecMmpimM5Cv86Jk+3n1JD62JEMubY/O9TME8cVLKTy+88MJRH9+5c+fxbE5wmpDTTfrG9br3zKGMFox6nXy0aLG6VatfkdXEf+lomADguB4hVaM9KKEAuu2LiVviWj2bUzRsPDyiIV+DAxAJqTz86iiXr0gTC4uBmIK5IxkJkgwHKBgWFdtlQ2eKbzy0i5s39vCNh3Zxy1Ur6wFNLbj510f3cvOmHgD6JnQR3MwAF//ipDaDa0I3CQVkLlvVTHXXF67CgmNyXEHN+eefjyRJTJfcqd0vicFjZxz5skU8rLKiOVbVxEg8tHOY5/uy9DQtZ117gnQsNGUCdzISZLjqRVMLbCJBBVmWsGwbVfEnJwdlhY5kABnYdiDLeUtTSBJ4XlV3IzkgQVzzpyoXLAfD9cjrFpIEcRHgCOaAJQmNZ3uzdDVGyFVbuGtuxLUgZ7rg5hsP7SISVLh5Uw+Xr0zTmtDQLZdCdZ+JBhVUWaJNaMOOOYnbxWM4XxH7s+CoHJemprGxkbvuuou9e/cedtuzZw/33HPPyVqnYIFyYEInb9hkdb8sNFKo8M8Pv8YbljXyrouXcdeWPYSq5maHTuBuTWisbUvQXXURHs4bFE0HLeCLBpEgKEt4rsdI0WD90hQTukFUVQirsq+7CR/0uKnYLoWyzZN7MvTnDRw8Xhsp0Fv1uxEaB8FsSUaCXHFWM43RIMnqyI/aHKnJwc3WXRlu3tTDd7fuZeuuDJGgwj/euIGRfJnWhMbW3RkGsmXGSiaDOYOtu8bQbYe+TGneXttC4ViTuA3TqQeUAsGROK5MzQUXXMDAwADd3d3TPp7NZqfN4ghOT/oyJXonyuTKFpqqsHX3GNsHcnz8zWv52oM7uWxVM+vak5iWH9AcaQJ3a0Kbcn9/pkTBciiUbSJBhXBQIR3T8FyPhoj/daxkYLvUNTUABcN/fktCIxpSmCjZ2K7H1l1jbFzZRF630A2bNtF6K5gFtXlSsaBSnyO1cWV62uDmGw/tAuDmTT38+Jk+PnndWvL/f/bePD6Owr77f8+5s7ek1WXJki0f+MKAw2HAhgA1RyDJU5q2aUhCGlLSNiehuSi5nyelaVoghDRpeCUhR8nT/J4kT5/mNCZQjnCHG9vgS5JtWcdq79nZmZ2Z3x+zO5aslWzrsGV736+XXmAdq5G0O/Od7/fz/XxKZRYlwv7r5Q99KV7dn2FxcxhJBFEU6DyFOzbxkMKB3ORO4g9sG2LTqrZjeER1TkSOqlPzN3/zNyxevHjSj3d3d/O9731vpsdU5wSgf1TnkR0jGNZBUXhHXONd5y/mn36zlT89u4u2mMa6rgYKpk13U4iuI8x16kyEaQypRDQvk6dUdnABWRTIFIuUgaawRmc8iAIkC0UiqsRg1iBY6QrlDRujbBMOyLTGNPpTRfJWmXSpTH+ywGtDWX/8VafOkRIPqXQlwvzjn5zBtoEs793Qw2DWqFncgFfg/NWFiyi78Fx/esLrpdrNbAoHyBoT86dOJeIhlbaoNqmr8Av9aYKKVO+41pmSo+rUXHvttVN+vLGxkfe85z0zOqA685+MblIoWaxeEMewbFqjno5mJGcQUkXO6GqgNRagf9RLPV4YlI/amKzavRnMGqQKpu9zEw16nRkRcBwXE2gKBXEcl6UtERzBJSB7oynXxbe7L5Udf/SVN23CqoRl2QwnC7TUQzTrHCULm0L8y5+dSbJgsjgR4oIlCZ7YPTquuAGvwGlrjbA3XeSXLw3w2I6k/7ENyxJ86NJlnNnVQMlyaoZqnmqIwFldDYzqll8c7s8YbNk6yI0XLUUWhLqups6UHLX5nmVZrFy5kl/84hesWrVqLo6pzjwmo5scyBpkKqOhcED2RcE3XrQEgD9a2UrOsAnIIkFFor3GyOlIGTua2psskBuzCh5SJUrlMiFJ5rm9aU5f2MALfSlKZYdwQCKkykQ0Cd2srINX5vGiIFAqOzSHFCwXhrMGLTM4xjqnJlXBe5WmsMoFSxI8vivJhmUJHtuRJCCLWI7LrpECN2zo4Z3rF/mjp+8+upu7H9zBp65aScG064GNeBlQqiLSlyzQWjHhW9fVQGdcozUWoOw6dV1NnSk56qJGURQMo962PxU51IumYHpeNOf3NHFGZwP3PLKLTavaOLenCQGBPSN5Lj6tZdbuqhYmwgc3piontoAkkbcs2uIao/kSnY0hmqMBRvMltg9k6UqEGMwa7M8YXL12AeAZ/OVKZQqWSEiWEK356atU58SiWuQ0hhQuWJLgs//5Mi/vz7CkeWInsCOu8Y3r3sAH7/sDAOGKVudUR1UkhlIFelrChAMyecMmokmEAxKj+RKFUt1ZuM7UTMtR+IMf/CBf+cpXKJfr7dJThSP1ommLaZiWQ1CVuHh5y6wLH6sbUyvao8iiQFI3cVyBlohGcyRAIqryQl8Kx4U3LG5CEgQWxINs3Z9BwEXAJahKhFSJbNHzuykDw8mC91bX2dSZIfGQyuLmMHe/Yx3XntXJYNbgly8N8L7vP8MH/v0P3HDv0/zypQE0ReSv37iEomkT0+RxQY6nKt44O8ju4QJD2RIp3WQoW2L3cIGGsOcsHKz/nupMwbSyn55++mkeeOABNm/ezNq1awmHx9+J/OxnP5uVg6szf8jqFlFNrrm9cagXjW7ZLGwMzunce2zrP6ObDGZLjBYtQgGJs7obkQQomGV+vyvJi/1pPvvmNUjAUN6gujkaCkgULC9jxhYFQi5g2gyPFECV6iOpOjMiHlJJ6xb/++k+PnXVSmRJJFe0iAUVLNvhu4/u4oaNSwjIIhLUn29AumgRD8qs70mMcxYGuH3zdq6/oAdFrHuh1ZmcaRU1DQ0NvO1tb5vtY6kzT8noJnrZO8HENJmYpvC77YO8uj/DdesXcc8ju7jl6lV+CF3DMTa8O1TbsD/trZnnSzZXrG7nT87qBNflD/1pzupqZKTiWnrO4iZG8iWcgMwPfr+bD1263H8MwSrTlywQlERa6tELdaZBRjcplm3euX4xsigQkEQCURXDdNg+kOWmTadhlMtEFImOulgdgJim8JtXBrhyTTsv7k3TOsZZ+OLlLbTGAhTnaQxPnfnBrGY/zXfq2U9Hz5FmOr1pTTvpokXfqM7Vp7fPi+2E/mTBy5iquLcGFZEX+tO0x70ipT0WQLcc8kaZhrBC2T74UoioEo/uGGHjsmZUQKwXN3WOgn0pnd6kTvqQruaNFy1hbKOhIx48YquDU4GMbvJ3/98LXH/+YlRFGKerKZTKRAMyoiiwakH8eB9qnWPMnGQ/jaVcLvPQQw+xc+dOrrvuOqLRKPv37ycWixGJ1EPHTgYyuklat+hOhGqOnMZmOhVMm6awytLm8LwoaAAkIKSKlCyJTNHCsiV6WiJsH8jyhsVNDOcNLylcgLLteuJjAaqyodaYRt60PQGn7XCg4voqKfXRVB2P/Skdy3HRK8VzLKgQDcjsTU8saKpdzbEGci3R+vNoLPGQymeuWc3//MUrrKqcW0plB8dViGoydz+4g49fsfJ4H2adecy0ipre3l6uuuoq+vr6KJVKXH755USjUb7yla9QKpX41re+NdvHWec4kNUtMoZJLOilYkc1mY3LEpy3qIl7HtnFTZtO83U0C4My7TFt3hQ0AIIoIDpglMvj7vi6EiEEPAM/GYgoEvsyBtHgwZVaP3bBOLg+GlElJMA0bfYnC8iSSGu9e3PKsj9ZoOzCQLZIOCBju1B2XPrTOp2xILGgwv60wc6hHNetX8R9T/b6Yvoqxfrm3QRc1+XjV6xgVLfIFC0Cssjju5KVTtdS6pKaOlMxre2nj370o5xzzjmkUimCwYMn9WuvvZYHHnhg1g6uFt/4xjdYvHgxmqaxfv16nnrqqTn9fqcqGd3ExsV2oH+0SNGy+c0rB7jn4V10NGqcs7gR8MzFGoLKvCtoABY0htCAzngQWRSRRJBFkfaYxmjBQBEFJNfFdl2iQYVIZa02okpENYWALHq5UkWLnGGRN21sYDBvYAOW7dBf3ZpKF4/zT1vnWDKQLCABggAxTUUv2TSEFDRFYn+qiOk6yJLAfU/2ctOmFfz02X6/q1k1gyyVHfRSvagZS0Y3cYGsYdGbLBCQRd+rZtOqNkTh8MGXdU5tptWpeeSRR/j973+Pqo6/iC1evJh9+/bNyoHV4j/+4z+4+eab+da3vsX69eu58847ufLKK9m+fTutra1z9n1PNaoGe2ndqikMvu1XW/n01atI5k3iQYVFidC8K2iqtCTCDKd0qHiAeJ0XhbZoEN0yCMoaz/WneEN3I9X75xeHcqxojTKUNVjaEga8Dk7VGyccUMibNiFFYiBb9OIayg77kwUUUaDlFM7vmWv2pnRyRpls0SIeVIhoMgun+H2P/fxYpXBVgGopUVVRGY6DiEAirB72uTycNRAAC8ibZRgTxGjZNuu6GxjJl2iLBf3YkOvWe3l5VTF9lVhw2gqAk5KRvEm+NLW5nuWcMjLQOtNgWp0ax3GwayjQ9+7dSzQanfFBTcbtt9/OjTfeyHvf+15Wr17Nt771LUKhEN/97nfn7Hueagyki/zqpQPsTRVJFkyG8yYv7Utzfo+Xun3fk72s6ohjlV00WWJRU2jeh/C1NIZQJe+pHtEUskWLnGnjuDLDeYN1YwqajG2wvDWKbhmctyTBSN4gokqEVS8RPGdY5A2vc6NbXrZU3rSxBCgDhuNyIFlgKFlgsJ4MPqscSBYQHJeQKhELen/HvFFm3yQJ133JAg+/Nsz+tPdcHsgYPLpjhJILuGA5Do7rYlUKGlkQeOi1YXpHCrw2mGX74CT5YJWOney6RFR5XOcgosoEBQFJ9EZRA5kiqzrivtA+HlQYzBoMZg2GcqUZuW2fjGQNi1TBQjedmh/XTRvn1NltqTMNplXUXHHFFdx5553+vwVBIJ/P8/nPf56rr756to5tHKZp8uyzz7Jp0yb/faIosmnTJh5//PGaX1Mqlchms+Pe6kzOkRrsretqIG9YNEdUFp4giddtDUE64hqS4MUkuK5LQJZoi2qUHBsD7yKkSRqK45AuughAWzSI4sJIvogsCV7+VOXNK3A8gWjetCmYtlfgACXAdKGgWwwkC/QP5xmoj6imzXBKx3HBAfJGmbRuEQrI7EsX+fKvt9J7SGGzL6UzkJn4+3aBA9kijgAOAvuzBkbZYShnsD9rcFZXnKFcEccFs+zwxf/3Mr1jitPhrIEhgAqYCOzLFCk7Do4LtuOyL1PERGBhJEjRsv1Q17xhEw8qNIVUlrZEWNYa4dJZdNs+WYhpCs/0pfjhE3vYnxlfUO7PGPz7E73Ua5o6UzGt3ue//Mu/cOWVV7J69WoMw+C6667j9ddfp7m5mR//+MezfYwAjIyMYNs2bW3jo+fb2trYtm1bza+57bbb+OIXvzgnx3MyktMtmiMBwgGZrFGmLSYzmDV45PVheprD4wz2OhqUE6agqVL1s6n62IzkS0Q1hXhQQREFRgqmnyvVFgsiA6ZTpoxEcyTINx58nQ9fuhzbPThxKDsOsij6o6nx51vvTt7FEy0P5YpYtoMKBI+xl8+JTtlxcQTQLRtJFJBEAVGAJc1hbnnTKu6u/G0WVtajzXLtO/2xj+dlhMm4eKvDAKlCGdv1wlJf3pvlby9Zzpf+6xVuvWY1Gd0C1wVRoAyU3drfo+w6WIKIXrL9UMb2mExUk3Ecl7CqEQ/V//61CKoS2wayXLd+Ed97bDd3/26H/7GNyxJ84sqVk9501akD0yxqFi5cyAsvvMD//t//mxdffJF8Ps/73vc+3vnOd44TDh9vbrnlFm6++Wb/39lslq6uruN4RPOXjG5SKNveHbAqEQnIPLBtkBf703zyqlXcuWU7N1+xwm+hN4VP3BNyR0OQjhpbSy2VVPDRMangIVWm7Dh868EdfODS5eC4yKLAYL5IOKBSKJUrIwRPd+NS0e24EAl62psqqizzh74UZ3c3ohdMsrqF67poAZnW+hhiSkS88Z7j4utjgorEC/0pFjQE+dClyzEcm70pnYWNocNe9lw8jZTtgijYVGUaggDhgEzZcWmNBbAdl1UdcYqmzYt701ywNMFwtkhrNIiEQFtlJVtTJA6kDfamdFqiARw8vUzW8Na648ET7ybgeJAzLH+le113Izds6PHPOVFN5psP7eATV9ZXuutMzrSKmkKhQDgc5l3vetdsH8+kNDc3I0kSg4OD494/ODhIe3t7za8JBAIEAvXws8NxqFHYIztGfKOwMzobfKGjaXknl+7G4Li11JOJaip4NRG8Wtx86NLl5EtFwoEgruPSHA5iuy4dsaAvNAZIFS0/bTlbtDy9hQACAmFN5rS2GHnTJlM0AYEF8QC9yTyGZaMAoXoHpyZlvO7KWCQBzutuZKhQ5Indo5zf04RueXl0At4oY7JYD4BoUKHsOEiiiO14HRXXhbxhIwieqNco26zraiBrlGmNaexLG0gi/H7nCOt7EgznD45IuptCdDcGcSrHqkgiUU2iIxasFzRHSEa3SESFKVe61fpOd50pmFZR09bWxp//+Z9zww03sHHjxtk+ppqoqsrZZ5/NAw88wB//8R8DnmD5gQce4EMf+tAxOYaTkX2jOv/9+vC4IqUjrnF2d6NvFFYVOhZMm+6mEF2nwAl6YSLM3pQO4HvVhAJBBEASBVygaNvki2XWdTei4uk9vvfoLm6+fAWG7RANKr6I1HE8c7+qnufQccdjO0bYsKyZZMEkrZsYtoMmSbiuiyQK4MKIXqI9qODIElmj7Dslh1QJGVBEgdZ5LtqeDkPpIrYLI4US4cBBLyHHBUeAllAQpUP2YzwAJEEgY1iTeizdevVqArJIJudt8BVKXjEUUmUimkSpkgkWUiVGCyatMYmUblIqO3Q1BWmNaRQtm53DB7U8u4YLEwodQRCwXdgznB/XPapel0cKJkFFQpMlZEkgfooXtdGgwm9fOcCVa9rpSxZojWn+SndnXKM1FhjnJ1WnzqFMq6j50Y9+xL333stll13G4sWLueGGG7j++uvp6OiY7eMbx80338x73vMezjnnHM477zzuvPNOCoUC733ve+f0+56sZHSTXMli9YJ4JR1XAgRGcgYhVeTMrga/c5E3bJrCyilR0IDnQyKA71sDnkNxzrLJFsuEAhJBRaItKqMApuNy93/v4KbLVxAA7n54J3+5oYeI6r3ELMdFEAVcx0UUBdK6VyhVxx2tMY2cUSZXsgCB5ojKV36zlZuvWEmpXEYRRZrDAVzAKjsUjIMFjXd0LiXbO+4FJ5ntvmU7lF0X23Gxx4hyB7JFWqMBZEEkosocyJnIkuB5LLleV9FFQBQ8HU48qKBFRc5Z3IhRtgkrXhfFdl0CUYlkvsT2gSxdiTB9yQJlx6UlGiAeVBjKlvxV7LzhaWU83dn4juWhhQ7AzqE8Z3U1kDXGryoLgkBLJMCvXxngmT0pbrxoCQeyBm1RDdc9qBypHvupUOyEVIln96Q4fUEDPS3hcaaZ4YCEKgoUSuVT4ndRZ3rMKPtpeHiYH/7wh9x7771s3bqVK6+8khtuuIG3vvWtyPLc+C/cfffdfPWrX+XAgQOcddZZ3HXXXaxfv/6Ivrae/TSevpECj+0c8e+GxuY6gXex7Rv1NkgWNYXmPHl7vjCU0jFs1xeCusBoRVQsCIKfpJAzPKfi6ogprHgeKPc8tpt3X9iDLIDoQtl10W0b14WALCEKkKt0BlwXCiWblG7SGFL9RGLb9i5md27Zzo0XL6Whos9ojwW90YYoMJLVueexXm6+YgWiICDiIosiiMKU3i0nGv3JApbjMJQr+Re5qCaTL1m0RgOMFkq0RIPkjTK6adMZC+C4LqbrjZCqGpyALKIKYLouyYJFRzSA60LJdXihL01nY4jmaIB0oURVZ9yXLHBOTxP/9JttXLS8hf0ZgyvXtDGULdEaC9A/On7DqjGkopvlCT+DpkgTNrTAG5Od1dXAgWyJHz6xh02r2vz3jS2CBMHT75RsG9vx7BTCJ6EWqz9ZoGQ73ParreNiEuJBhc6GILIAI7pFzzz2xqozNxzp9XvWAi2//vWv84lPfALTNGlubuZv/uZv+PSnP00oNH9OrvWi5iAZ3WR/uujPrQ8N3esf1Vm3qJG+pI6mSCxKhE6qC+VkZHSTbNFiIFskpikEZAFVlKjuubh4oyRVEHAEyJm2vzGlySKm4xCSve5J0SmjCBJCZQg1lPfuwp/tS9EW9y5GIVVGEPAvknnDExYLAmiyxJZtg1y5pg0RgYAiUrIcv5vTGdewHYd/+u12rr9wMSDQGvW201YtOHme3/uSBRwgV/J+17GggiKJvNif4szuBhRBoGA5KJJAqezQFJApu5C3yrgIfiYTuEQUGVmAnOX9RTNFy++6yYKA5ToUTZtX92dZ3BymMazyjd+9ztvPXYRh2fzoiT3cePESdg8XahYUtQqdKmNN98ZSLXj2ZwzWdTWMe99YvGKnEctx+OZDO7j+gsV0xIPguozdw5JEAU2RPM8X3SKsegVQwwnQ7alVwFbDLFujGoogsC9rkAirLG+bO0+0OvOPY1LUDA4O8v3vf597772X3t5err32Wt73vvexd+9evvKVr9DR0cHmzZun+/CzTr2oOUjfSIFHd47QdkiXZkE8yA+f2MNNm05DEgRe3Jtm47LmUyZJeNdwHrHSYQmKAgaeSRsc7Ng0RwLIggCCQN4skylayCK0RoMUxhQ5Va2L47r8oT/Nuu5GMrpBSAsgAMl8iT0jBboSIf8i2RrzhO2u6xmNFUplQqqMJAqEVU9LM7abkwgrvDaU979ORKBgljmvJ3Hsf3lzQC1HYMlxsQRPlzKU80JJD2QNwKU5ohESBSwga5TJGmWimmdN8NNn+/nkVStRBYHwIRf4jG4ylCt5RY4qoSkSlu1g2d6468HtQ7zYn+aWq1eTKpRoCKvcvnk7Fy1v8R9DgCk7J6Up1syrBc/Yz6lVBGmKRF+ywJrOOHdueY3LV7VN0PFAtbMTQDdtNm8d5IX+NO+/eCkLYuNHW4ooEJ1Hxc6+ZIHSFEWNi0uhsip/7uKm4324dY4hc5rS/bOf/Yzvfe97/Pa3v2X16tV84AMf4F3vehcNDQ3+51x44YWsWrVqOg9fZ47xYhBq301WtTTgXVQ3Lm85ZXQ04JmqBQSBsgAGsG+Mgduu4QJLWsIYlQtPyXJRFdEX/eZNG9txiIcVQpJEfkyB84buRhzHJR7UsFyH5yvjjjcsbmI0X+Kcnibu2FztuHgdnLEiVa9Y8U7wY7s5eVMc1+GRRcHfvporqgVAuniwCxA8pDOgyRKS6G19pYomEU2h+QgiCMYymCyggK9pqm6TRVQJnCKmq9EY9tauo5pC3rAq3TKXR3ccLNiLls1Q1uCmy1fwT7/Zxi1vWjXhOKoeRuO+f9YgVTDJGhZXrG7nj8/sxHYdCiWb7z62nesv6BkXrtgUmVjoVBnbhalFtZgZW8jUKoJKZcfXX63uiNcULFepannO72nijM4Gvv3wTi5f1TZhtNXsuGR0C6dS7AhA6DiNtiJBhVJhchfuF/rSLGuLElIkMro5b4qxOvOHaRU1733ve/mLv/gLHnvsMc4999yan9PR0cGtt946o4OrMzdkdGtKH48/WtlKvmTTFFJPqYImo5sERIESXlcmb9p+wQLeunfVrA3AsMqUygc9Tqp+J2LJJo1FUJXIGWX0ks3vBjL80co2coYnMj6ruxFZEChXLpLfe2w7N1+xElHwOjjbBrKsXBDzN3OaI14n5kDWGNfNyRkWtoPfvVElcdwxz8bvZChXIq1bhANesSIIEJBEEmGFounw5K4ki5vDtEUDRFTJ7wzceNESJNHTgvQldW7fvJ1PXrUSGVAViZYpLprDyQK267n/SJWujCgIlVgDF1UMki/o5MoiLZEAkuD9fRRJpD+Vn/B4LpAqlPjzc7rHeQdNRVUkP+73ULRoiQX4+BUrfQNGF5f+ZJHbN08sdMC7OdiydZCOeO2ft1rwjB05TVUEVcMwq3qTWoLlKqO65T9mtQga+z7wivWeljBxTTlY7OSgaNqYrk257BKQvL/7XIuW4yGVglGmVmxlMl+iszHEtoEs6xY1MpQr1YuaOhOY1vhJ1/V5pZU5UurjJ4/dw3mGcgY7hwsTxk9LW8Ikot6d/6kmxuuvnOirF71s0WKsNUpVzFu9aAVVCVk66HFS9TuRRNELPLQdXt6XAeCXLw2wrruR5/pSbFiWYP3iJkIB5eCoSpEojxGsgidSPbcnwXDOwMXTa/zTr7eN6+Yokuiti1d0Nl1xjc7DjAqPtNNy8KJN5Xh0/uOZPq6/YDGiAM3RAKP5kv876kvqnN4ZJ2t42T0Hha8C67rjiKLI17a8xievWoHtuCiCiOt6W2FF2yYoeVokF5d82UEVPY1SdbVdFD11koiXu1QWBAzHwrAEGgIySd0gpgUYnOK53RwNkMybMx7PPb07yWM7k1y0vBnb8Vb0x/7OHFwM0+aBbUOVAm/phGIHvILnh0/sqXRQGiu/O9v/3R3K2GKnGo45lY4Hand/Dh1ttcYCZIvlccWOAKzvSdA7qvPDJ/Zw40VLvJTsimi5OsaaixFWf7JAsmBhlG1ClU7dtoEsixLVJQaJolUfQZ1KHDOhsGEYmOb4duF8LRjqRY3H7mHP7G0ykXBbTEOTRTpOAWHwWLYOeNlg2UrkQaxizlalKuaVRO+CULY9cWqm8vnxoEKmmh6tyjyxK0l3wvsdOi7c88gurlu/iPue7OW69Yv4xQv7uGnTaaT18oSTt9f50Hi+P8XpCxsAl7sfeJ0PXnaa383ZM1Lg/CUJXDyzN1UUCLhQcD3XY6GyeWXYDi4QlKVxegoH+G1lnfj9Fy2lLeZpMLZsO9hpOfRC3BgOcMf93ohFAHpawuyqjD5O74yTM8o1uw2JcICtAxlaYxrtMa1ShEFHPMhgtkhbLIiKl54tuAAuX3toBx+4ZDkpvUgsqGHath9MKgsiwUqI6N5ciYJRpi2uEZBFBrMGdz+4g8d2JP3j3rAswYcuXeYXOjMVUm8dyPKmrz0y4f0hVeL9Fy/hqjXt5EplT58zptjxfu/jC56q1qVgWty/dfIiaGyxsz9jcMGShO/lMhW1dDqHjrYaQyop3ZxQ7LTHNF7Ym2Z/xuC5vhTXrF0AMGFDqzmqeeL5imh5ph2djO4FkBqWU7OweWJ3kk2r2ljTEZ/W49c58ZjToqZQKPCpT32Kn/zkJySTyQkfr5XgPR+oFzUevZVV7slEwrdevZqlrZHjfZjHnCd3ec/lWMXcK6JK4zQ1u6tt+srHX96bYUlLiJaIRtn1hlKSIGC7LiFBoITAQLZIb1JndUeMgCJRLjsIggCCt0UlSQKqKFKyHXJj/G+saiGiSP6IKyiP7+YsiGteIVARQqQLOt94uJdPXLmS0YInoNWApGmTrRRbYVXCdooM5ryfqTkaYN+owb2P7/Y7Az3NYQzLqdktOFQM2xoLMJQtAdASDbA3VazZGWgKe5ESrbEARdMhqHqfIyKQK1nsHi6wcVkzguv9MKLgFV3/8OutfPpNqyg7DqMFk0jAW213XOiMe1EXBcvmri2vccubVmHaLl/+1at+8Gr1+V0t2m+9ejVBVaoZk3E07E8X+eT/eYFHd0w8/21cluBDly2jpzkyYSx0qCA5rMoE1YNdskOLoFodn+oW1sevWIksC5PqeICaG1W1RlvVv2OtYqe6ov6+7z/Dd95zjv+xseOyaoHbHtMYzhk47sSODhxdsdM7UuD3YywnqgXrqX6eOlWZU6HwJz/5SR588EG++c1v8u53v5tvfOMb7Nu3j3/7t3/jH//xH6d90HXmnoxuMpwrsmSMsVVUkwmpIpIAZ3Y1YJTnZ1E614wtZgB+8nQff3ZOt+9X01IZt2iyiCwInNfTxIGswXP9adZ1NfgeNpLgbd8EgYXxIC1RT8yZLngOt1FF4tFdw/znCwf8O9/TO+OYtkNEkLy7XdcLy1QkCMkSectmKFcipHp6HAHPDFB3bBRRQnMhGtT42BUr+Opvt/GJK1fy5K4k5y9JIEnQHteQK1+jCUFUQWfrkO7rKVZ3xP0L8N0P7uCatQvGvW8sY8cdVSM68DoJAVms2Rmoip7zhk1M89x/q0Q0T5SaN23vdyt6Iy/bhbed3eWbErbHNNJ6maZwgKJl+2PC7Qey3HzFSmJBhf2ZYs0wxA3LErx3Qw+mbbO0YeYXwo6GIF++di23/vylcYXNxmUJvvDW09EkoebvrpYgGWpvTXmCfoNCyebSFa1cuqKVB7cP8dLeDJ998xr6kzr3Pd1bU8cD47U81XVws+xM0PcIeOOc6vN4LBHNc1KuMvZvWyo7437GcED2YySq3btaxoNVg0ERsN2p4ynP6mpgVLf877s/Y7Bl6yA3XrR0XPerTp0q0+rUdHd384Mf/IBLLrmEWCzGH/7wB5YtW8YPf/hDfvzjH/OrX/1qLo51xtQ7NdA/UsB0HZ7cNTquUzOYKXLekiZKlk3BPDVn1XtTOjguIoDrYiLw02f6+Itzuyf41MjCwW6C6bgULRu9ZBMLymiKiOAKJAslVFnCtB0yusUzlW5BdQQ1dsTQlyywfomnn7Fdl7ZYkP2VC0Q8JBGSlXHbVBFVIlM0kCSvEAurEiKwN1OkULJZEA9WiiIRVRL5h1+9yufesgbN9UY2qgAvDnmC2kPv0j/w73/w78hrbeCMvXsf26lJhANs2TZY02vl9M44w7kS7TGNgCJStA4WznnDMx9sjqj+5lZIldBNm7Lj+Gu9siiSKVpEKyny0phJSXtUo7s5zPbBLM/uSY17bv+hL8V3H93Nuu4GPvvm1axsn73XfjXxvfp3Catep20qEfTRktFNRvJegnw4IKNIAsmCiaYcfrR140VLkUQOcS4eP9ryunXFcd06mNiVO7RTA+OfH9URVldT0H9OwFSeOw2oijhOlzWWlqjX9Rmrj6p2a5a2RGiJBlBEgbLjnlKuy6cqc9qpGR0dZckSLxQuFosxOjoKwMaNG/nbv/3b6TxknWOEAAiuwJkLGypbE56Hx8OvD7O4OUxHXEORZsWPccZUT+bZiuHa0a4EHy0LG0MMJwvgQgkB2y3z5+d2kx1TTERViaAo0HIEvj3dzWH/Z3BduGbtAt68dgGu63LL1asoWQdN3tYvSfDi3jSrOuIIeC/M6oW8ZDlkdC9Y03M1hrRhIUsKuaLlL4oEZG/zKRyQyRmV7atKPtS7zl/Ml/7rFb7wljUoeOvq1QtStdtyJIJSgJgms3sk79/hD2YNBARaoxqv7s+M6wzIlavntoEstuPSkwgzUjD8i1ihZNMaC6CbIlFN8XO2YPxmV96wkURPW1FdbZd9bZOLURl5q6LIL18amKCnuesd6/jIj59jyrbANJgs8X02qdXdWdw88fOqo62i5bBpVRtvWdvhF34jBZM3ntbKlasX+EWQANi4vq7q0GJn7Ir6/ozBhmUJBrMH/XAOHWNFNAndFMd172BiR6fKqG7RlyyM02WNpSU6dWHo4KJbDtmiieNyykdM1PGYVlGzZMkSdu/eTXd3NytXruQnP/kJ5513Hv/1X/81zqumzvzDFbx8mkNNyW7atII7t2znE1eupDV6/JPN+5MFBrJFmsIBVEkkmTcxLM+Mbi4FzC2JMMMpnYDjgiCPcwyOqBKKKNByFN//0AvS2BXpkCpxzuImLNtBt2xO74wzkjdojXhRCIVSmQWxIAO++Fjytqpcl7Ru0h7T8JaevQLAqYwTwRMtZw3v63KGRapQYlVHnKxRJq7J5CujIvAuRo6r+HoL8IqZye6wexJhlrZE/O2nZa0RQqrENx583e8MtEU94WtvssCiRJhFCW/l2wWaI97FysHlB7/3vHmGsganjdFHVH/njuP6a+yyKGLZDmFVIleyfE3N5//rFW550yoyusmXf/kq67obuWFDz7hOzX1P9nLDxh70I1znPhGZbLQFsOiQImjsBtyhxc6hK+qG5Y2xPnTpcr/oOXRNfewI68o1bejm+GJ4Ks+dcECuWfRMPZgCw7Qpmg62e2TjLnce+PDUmXumNX664447kCSJj3zkI2zZsoW3vOUtuK6LZVncfvvtfPSjH52LY50xp/r4yV+TtGzCAS+8cttAhjO7G7nz/u287ewu2uPacd8o2JcsYDgOQ9kSP39uLzdevJSy7fqustGAzMIT2D8no5ukCyaiIIyz8vdSvV2iquy31IfzJURBpDmsUC01C463YTJaMGgKayiiQN60yRtlNFVEREBVRAqVENKCaSNLAn1JnZAq0xDyCp0dQ3lf4BnXVA5kDT543x9Y193Am9cu8FeMx7IgruE6LkJl0wWg5Dg4judlMrYzUB2PiBV/k2oTwHVdepNFfvx0LzdfsZJUoURrVKPklAlKMrbrUrQcRMETSv/jr7dy/YWLaYtqPNOb4ryeJkRAA7728E4uWdnGkmavc7ZrpMD3Hts9oVPz3g09yIJAV1OoLi6dhENFzEFFwqz8bVVJwhUmX1OvjrC+//hubrx4ybjOy+E8d6pjq0PpbPBGTjuG8jXHT9UNKMd1j3jcNfb5vCAerHdxTiCOafZTb28vzz77LMuWLeOMM86Y6cPNGadyUdM/qvvdjmpBs3Ugw6LKynHRdEhEVQzT4dye46en6U8WsGyXJ3Yneb4/xQcuWc6XfvHKuG2WhpBCV0NwXkU3DKZ0ypVio6q7kQSByqKTf4foVP5bFfpaMEErI7peN0YRBdJGmZgmU72nLLkuB/IHixkRMJwyiiijWzZp3aQjHuSZPSnOXdzIC3vTnLmwgVzJZk+yQFdTkKJpE9UUskWL5mgACfjVKwPc/budrOtu4MOXLWdBTPMdZsHzhpnp3e1g1mC0YI7z5nFdb3QUrgTgSgLszxVpiwZxXfjGQ69z48XLUERIFko0RzzBswLsSuk8smuUbQNZ/uXPzmQoX+Lp3aOT6mk+ddVKFjWdWt5Ls8XYzs7YDa3qCGvzKwd4dk/Kj5GojhePxHNnrC5rLJIg0NMcnnID6jPXrCaZLzGcH18UTRYxcagPz4ZlzeB6nlOzqYOqM/sc80DLE4FTtajZN6rz8OvDk6Zx9yZ13rCokeGcSSKsclr78QmK25sskDO9NOuBTJHuRIjbfrWVd5+/mIFMcYKwecOyZrrnQWGzP1mg7ELZdfx8qEQkMG7FWxKECWvfAVHEcl1+vzM57qQ9lDW4cGkzyYJBS0RjOF8kqKoTMqVEPFdhGxguGLRGNBwXRnWDxpBGWjdoCGlIAuzLGJQdF8Oy6WgIEq1seAUUiYxh+eOwcKWTM5cX/urfeWwhV7TLBEWvSyOJAoLjUnAcr9PjQt4sY7sut9//Gr/bNuw/1oZlCf7X/zidnpYIu4fzfOY/X67ZpfnIj5/jp3974UkV9Hm8GRsjUS1SHdfFPgLjwbGmg5NpagAuWtpM3iz7nloBWeS5/nTFU2spnXEvD2rHIV8/Wc5WLR+eXMkirimEVdl7QdV1OPOSWRcK33XXXUf8zT/ykY8c8efWmVs8Eyudnhor3KIAu0d0Vi6IUbIcYppMW+z46GkGswa5ip8KeCelsu1yZlcDmiKyZeug360xLJtFzWEKpn3c81/2pnRsYKCSpVXNhxrKlcaZ8dUy6CvYNnFN4azuhnEjqI4Gr0sSVCT2jOi8+3tP8R9/dR4djSHyps1g1jhYDFSSwFsiGlKlwxMLBnBcl4Aq47jeplZUUwiqIl+tZB8tHFMMHus71IWJsC84rQqDQ6rs6TJUecLx7BzK879+tZXn+tLcsLGHd65fNO6u3cV7nn/ukIIG8P99w8YeiiexnuZ4MDZGosqhYuU3r+2Y0nOnNebpspa21B4Jll0vX61qMliNh+iMe+Gvlutglt0pBcxjObTY8QJiZUZ1i+f702xY1sxgtsiBrEF7TKsXNycgR9yp6enpObIHFAR27do1o4OaK07FTs2RrHCXHShZDgsaNBYeJxfhbQNZMhXNjOO6HMgYRAKeMdmdW16bvFuztJnu5uPXram6EFedh6uuwzA+NqFWlEJWt1AkiAVVyo7rdy5kSeBAyuB7j+9mdUec5/pSrOtuZOdQjk9csdIz6hvTtVEAXJe+rDEh2bgjFkSuOO/ecf92brp8BZoo0HYCuUXvGs5P4RK83C/Ef/bcvgmGe999dDe6afOd95zD4kS4rqc5TmR0k8FsRa9TMZiUKx3LWhegagEUUmWSeQPbZcJzWxIEgpXVf/coxl1jqYbBVt2Uq52bXcMFT4fT3eiPScV6B+e4Muudmt27d8/KgdU59piWw6JEeEIkQnWFeyBbojGkHLeCBvDXtmVJIFWwGMoadHQ3YtmO362ptarb0xIhPsfjkimPu9KBqWoISmXH30DyAy6FGqGXgk0oIKFIIn2jOs/1p/1Nkl++NMBzfWnuesc67nuyl/du6PGjFb66eRs3X7GCprC3bvvn53SzLBHEFUTiQQUXAVGwkUTv32JF92DYNh+7fAUynFAFDXjHLwreSnx1q6napan+fA7wXF9qguGev8oNNEfqF6PjxVSbWYcyttsTUcFFYNfwQbGwbh4UCz+wbYgrVrdjO85hx121TAcB31KgGg4a0Q5uY40WTJ5P6qzrjpMpWhzIGnQ1hlgwx2v8dabPjON8q40eoW7vOC9xBWpmPF23fhH3PLKLz1yzGk2RKuvBx4+qcdk3HnydD16ynEQkgCoK7M9YXLqila/8ZhvP9aX50GXLxt2N7xrO0xHTjktRsy+l+y7E1U6Nbop+YvbhOjVl2yGiSgxlDV7dn+Hs7kZCqsiHLl3G3Q/u4CM/fo4bNnpbOzdtOg1VFvnYphW4rosqinzqTavQTZv9eZOWiFLxeSn7As6IKiMD+/MGQVVBVIQTLs9rb0pHqWWXOwZFFLjl5y9NOXpa2Bis32GfIIwtgJ7tHaU1GmDn0MTkdd20ebE/zbVndTKYKx/RuOtQH547NnuWAlU35aonUnVM5a2dBzAsl53VtfHhAhuWeoGo9c7N/GPaRc13vvMd7rjjDl5//XUAli9fzk033cRf/dVfzdrB1ZkZ+0Z1Ht0xMm7u3RHXOLu7kR8+sYfVHXGKlk1rZG5N7Q5HRjfRZJGRfJG/vWQZ33jodd7/xqVICDSEFEplh+f60nzjujcwkJmYRuwcJ6171igTUSUcYCDjbV8MZY3Kdpl3wiuUyv5/D33f9oEs5ywOceHSZhY3h7nnkV2c2dXAH61s5QtvXYNpef41DUGF1mhg2n+j9nkgpp4OGd0kZ5RpUL2i+1AxqYAn9JSAR2pkMIFX2HzwkmXHvWivMz2CisTmrQe4YlU7+9LGuLiEB7YOcsvVq8F1JzigT6Xtqfrw3LF5OzdfsZL9qSKv7s/QWeniVDs3VUplL1Rz7Hm0YNpki16MRWc8SOcJbDFxsjGtouZzn/sct99+Ox/+8Ie54IILAHj88cf52Mc+Rl9fH1/60pdm9SDrHD0Z3WRfWq/5sZAqcmZXA6d3xNFL9nH3pRnMlig7NtFgANd1+csNPZTKLiNFg7Z4gLRu8ddvXDLpCGpJS4TGOXYbrkW2aNGgSjgudMSClF3Hz4eqbj+FYxq26xKOHQy9rL6vmh2liTpdDSE+c81qiqaNbtooknjKdxdG8qa3dq5K2Ag1BdWS4J3ETmuNcMXp7TU1NQFFPKV/jycyYVXmiZ2jrGyNoyoCXU1B8obNlWva2LgsgSzAcMGk+xBzwVrjLt9SoGjRGvNy0ja/etBNuTl6sHNTFR5XdTjV7LIq2aJ1sHMzlGfDsmYcp27uNx+Y1kp3S0sLd911F+94xzvGvf/HP/4xH/7whxkZGZm1A5xNTiWhcP9IgYJVxrDcmt404YBM32iRZS2R47bCXeXp3aMEFJFvPrSD685dRFciSNGqiGGDCgJglh3u3PLapOnLn3/zGhYdY8Hw1oEs2UKJzoaQLyQ8Gp+a6gvv0Oyo9uM0TptvPNeXQlMkGivePSWh4ulTKWoiqoSG9zstcfAObXdS56M/eZ4V7VHeu6GHJc1hlkyyXVNnfpPRTbYeyPHth3eOe+3HgwpNIZUHXxvkjae1HtWNWTUoNFssE1IlAorI3tEiP3mmzzeDdNzxouNqdlmVlmhg3L81RaIppNTN/eaQOc1+siyLc845Z8L7zz77bMrlco2vqHOs8YSTaX8NUrfGe9NoqkRDUDluK9xjCQUktmwd5PoLFtfccPncm1cjiUyZvqxbx/55F1Ylvv5ALx+/cgWSKI674IZUyTPXc1xSRW9Tqfk4j/mOJxndJK1bFMwyBfPIRmoxTUES4Z7HdvO+C2tvX5aB3aM6riCwIKYhidDdFOT//u2FuI7F7Q/s4tNXr56jn6rOXBMPqSyIaVy+qm2cl1NvsoBZdnhmT4orVy846seMh1TfZ2e0YNIW1/jUVasouw5BVZqgw9k2kKU8JnWzJRqYkG8FjDP32zVcYMOyZt8J/VR97R9rplXUvPvd7+ab3/wmt99++7j3f/vb3+ad73znrBxYnekxnNIxHRfdLNNdY+Opp3kJ/aM6zRGNrsYghaJFumihVy7IsaBCY1itmcWyL6WTNcr+izSiSrPyYg0qEi/0pzmjs2HChstQ1iAoS+gWE+zv4aAY9HNvPvYXrnhQ4eYrVvLPv93G287uojUWwHa9Lo0AhCu/m0XH/MjmF/tGdfpTOl8/pGC9aHkzX3nbGZMGQjZHVP5l83Zu2LiE7/x+N+/ZMLGweX5/ClX2dFcNQYUX96Y5q7sBgIiq8PebTvP1THVOTBzX5ayuBkZ1a5ymZsvWQW68aCnT3VE51GdnX0onlbcxLJtLV7Ry6YpWtg1k/eyysTy4fYjTD+kOZYrWhPNmziiTK1nYLhRNm/b61tScMyOh8ObNmzn//PMBePLJJ+nr6+P666/n5ptv9j/v0MKnztwxkCzgVBxmM4ZFLCgjCgJRTWbjsgTnLWrinkd2cdOm0zDKNgFRQndcPv//Xhl3sdm4LME/XLt2nFtvf7JAX6roF0mP7Bhh6/4Mn33zGkqmTesMXqyyIHDjRUu455FdrO6I+ycGTZE4q6vRX718bEeSkCpxw8aeCSOo40E8pFI0ba6/sIdwQPI9NHKl8pwnip8o7Evp/PfrwxO0UACPvD7Cp3/6Il9/x7qav6t4SOVvLlnGtx7awQ0beygcMnoaSOv8f8/u98cSWaNMa0zDrTxjciUbAtKE9d46JxYunuVDb7Lgr3Wv62qgI675f9vZMOHsbAwRCcjj4iDOXtSEIBzcpHp1f5aWqMYL/WlaIge73FXtzWTmfvvSRSTR89WpnxfmlmkVNS+//DJveMMbANi5cycAzc3NNDc38/LLL/ufV1/zPnbsS+mIeNk5huOwa/jgCaBo2b7Z3jmLGwFvXpwzLL7+ux0TLjaP7kjy9z9/iduuXUss6GUEPTLJFtX//MUr3HrNagLTPKlkdBPbdWmNBSa0mPuSBdrjnsBWN735913vWFdzBHXtWZ3T+8XNkPaGIEFVYiRvYtsuIUWmu7GeLwSeMLM3qdMW0yY8x6o8/PoII/nJnzsdDUH+7ooVFQ2ERVCVsGyHnz1/gBf601y3fhH3PdkLwJVr2kjpnhC0Sv0UdGowlCvNymvuUIHxvpROb1InXYlo6EsV+c0rB8ath1c9cIAJ5n7VFfFM0aKrKciBrFE/N8wx0ypqHnzwwdk+jjozpLpeLAKCK3DmQu/OtS0mM5g1ePj1YRY3h7liTTsjOZOGkIJlO5NebB7dkSRn2nzxF69y69WruGBJonK34rBl22Bl3ryEMyp3J9WTylgRXrjiHBqQxUn9UYZyJQQRUvnSuCiHiCYRDkiM5ks0RwKEAzI3bOyZdAT1hf96hbsnueOfa47GWOxUoX9UJ18qky5ah/3cnDH151R/v/2jOn2jOpmixekdcSzb9U0Jf/xkL+u6GgjIItGKdxAuXoFTL2xOaCZGU47HxfVjSGabQ7s3bzq9nWvP6pyQWF4trqcy98sbNpLo0J8szKsw3pONGZvv1ZkfZIsWkgSaJDGQNfwx0WM7vTHRJ69axZ1btvOJK1aiKRK4+M63Uz3mygUxPvOfL3PN2gX0NIcRBTi/p4kzOhv8UVauaCGIAgPpIg9tH/K7LbnSQXFy2XFrhk+mixZBRcRxGdddGusaCl7O3IVLEnz30d0TDPiqq7sDGYP9GYOw6hVT9dTd40N/ssAjO0ZY2hKpmZZ8KFFNOaLH7WoKeXEQePqF6l3xj5/s5VNvWsUd92/n4uUtdDR4f3d5bIFT54RFOsz8sD9Z9KNJ5oKpujdji+vDmftduaYNEYFkwUJVjJq6xTozZ1aLmn/9139lZGSEz33uc7P5sHWOgHhIISBKk5rt/dNvtnLd+kUULZumkELBsn3n28kIByTWdTVw9+92cMOGHu5+cAfXrD24abC6IpSLVvKaepM6v6jhI/OhS5fx5K4kIt5dV3Wl2XJcQqq3+XR+z3jzrCqCAKbjEJRFNEWcdPx01zvWoZtlWsIB/tCX4vSFcYykjYI3k5dFgZYTzE33RGTvqE5fysvoCqqe9qojrrFhWaJmV/Di5c1HFV/QlQgjiAIZ3SJrlLlyTRvruhq44/7tXH9Bj6ezwAtCfK4vxbmLm2pmC9U5cRjOG7THgjXNF5siXlzIp69adcyOZ7LuzVTmflv3Z9i4LEEiEiBXqmxc1YuaOWFWi5qf/vSn7N69u17UHAeiAZl9qcnN9s7oaqi0QW2KlkU44DnbblyW4NEaF5uNyxIMZUvj7MIf25HkhjEbKG0xjaJpE4nKuC7c/fjrrOtu9LeXql0Uv6Nj2kQVERehkucjjNt8OhQBaIkEMMo2jgiNIZV/uf+1STeg/uf/OB0Zlzd0NTBUCcFbEAuCC7btMpAskHdsRnNeSnZEk49r3tXJxt7KaGjsKKAa//ChS5cB1Nx+OtrR3cLGENHAwTFne1zjE1euRBW959VgvojtCJyzuAnFcQmG66PBE5mgqvDbrQNsWtFO0bIr4lvvhuz2zdt5z4U9qEfQEZxNjsbc79k9KW65ejWpQomSZRNSJXKGNSvi5joTmdWi5oEHHpjNh6tzFNh27bTbKn+0spWcYdMUVgjKou9y+4W3ruEL/++VcYXNxmUJvvQ/TufP/+1xvvK2MwD8McKh6v6FjQoZvUQ8FOBTb1pJwbDHaXl2DuW4bv0iRMHTTgTkAKVymYAsIYkCAUHg/Rcv9c21Dt18eq4vxZldnrjZqMQlTDZ+KpUdFFUib5YJBRQUSSRXshEEl4AsoQgCQVGiKeJgmC6P7xhh/ZJEzbFYnSMno3vOv8mCRdGy/efKg9uH/K22M7sa+NRVKwFvtTUWVGiaxDrgSBh7UanquJL5MqGARENIQxUFirZBQK2Ltk90QorEkztHWd4SYyDjdQGrqdoXL2+hI66RNSwWcHzXpdtiGposMiqLFC2H0bzJJae1cfnqdl7sT9HZGOLV/VlWLogR1ZS6aHiOqGtqThIc1yWmKTXTuHual6CpEgICIcUzhZMEARcISgJfvnatvw0V1RRUSeQ9332KFe1RnutPs2FZguf60wDjNBJBRaJo2ph2pWBRJLJGmajmFTQ/fbafmzat4M4t2/nIH51GVPOScF0EvziSRFgQC3D5qnZaY4Fx5lqyKNDZGEIQvIJGN8uHHT8B/kpvyXLIl8pEg56PSdX/M64oxIJAe4iBjLdq2Vnv2EyLgXSRdMU/xKiMNB/b6Y2cqh24TavaaItp7E0Vfe+hi5e3zFr7vVrgZHTTj1aIagqtkWj9onESIAK3XL2K2361lVWH3PhcsLSZgmmRO4w+8FgRD6nkjTJP7BqlNRYgWfCKL6NyvluUCLN9IMt5PQmGciX6koX6TdUsM6s9u1QqxQ9+8IPZfMg6R4gkCpTKnjV/V2OQlkiA7sYg7z5/Mfc8sgvBFYhpMgKgKBIlx2WkYKKXHRzHZTBjkDPK/PKlAd5y96N0J0K8d0MPr+7P8N4NPXz30d1sWJZgMGswmDUYyhp0NGi8NphDN21SBYucUaYxJPPAtkHue7KXj25awde2bOdPz+7CdSGiSuSK1ri3jF6mYJZZ1x0nEQ7QFFZpiQY4vTM+zp0zZ1g0htRJt5++99humkLquMcumLaXXD32exoWtgAWEA0GyRStCd2nOkdGRjd5aPswo7qJYdmEAhJD2RJb92dYEA9y40VL+OETe9ifMfyvCSoSF5/WMicBgPGQytLWCGd1N7K0NVIvaE4SYiGFtG5y48VLuHJNGyFVpqspiCTCcM5g86tDRyw2PxZ0NoV8/Uyt89kbFjdhuw6hgMRjO0boTxbYO5xn/yTygTpHx6x2avr6+njve9/L9ddfP5sPW+cwVNO4J4tEOLOrAaNss7T1oANmyyGP0RRWGcmbNIZUrlm7AMv22qerO+J85MfPsa67gQ9duhxR8MS7zZEA/cmi79uwuiPOm9a0o0qSvx1VFSd7Wp4yDQGJaFDxc5DAc9+9vyIU3lnZfhqt3N2UHdfPTopqiq/rqcVjO5KYtuM/PoDruCiy4OdHVcmb3ojk6w+8xs2XryBbd5ydFgeyBq2xAJmixcJGr/X/f57t55NXreKffrOVM7oauGnTaYA3clrYqNRzreocNfGQSmtE47GdY85xle3IBfEgL/an+eMzj49P1WRoioQml1FEmYJpE1Yl3rCokdFCidF8CReX5ohGa0wjb9pEVAnbcdk7UsB2XQKKVHcfniZHVdRks9kpP57L5WZ0MHWOnoxu0p/SuX/roO+salg2i5vDxDSFrQNZLl3Rim5O3Z49VPiW0U2CikRYk3nT6e1osoQgQKlss/nVQf7tv3ehm7afvXTfk738j7M6KFq2n167qiNOayxAvqLlcfDGV6WyTUCWkEWBsuNOKRRui3pJzIIiMpzzUnIncxVO6yYd8SB5swwIhDWZZ/eMsqoj5mlqKvuWA1kDJyDz3o1LyJtekGSdo6N/VPfHTtWR5LaBLNdfsJg7t2z3i9m8YRPTZFqiARJ1l+U608RxXS5YmmBf2hgXlfDA1kFuuXo1juvOK+FtS0yjaNk8VrnZHMmX/NHreUsSjOZLyII3hq/6NGWKJu0xDQHYn9Exbac+mpoGR5XSLYrilC7BrusiCAK2PfsXiS9/+cv88pe/5Pnnn0dVVdLp9FE/xsmY0t07UuCLv3iFd5+/2BfRVS/0g5ki5y9JUDA9Ye7ytpmlcfePFMibZUZ1b8MlIIs815/m1f0ZbrxoKVFNImfYvrYFIKTKxDSZhsroy6m0aarPItuFfZmiH5FwaApvRJWQBdiXMwgHFN72zd/zjevewHDOYOUC72+omzZBRaIxpBBwwQRs1yFZMGmOVIoiDs5a06ZN3igT1mTyRYt4SGFF+8nxfDgW9CcLJAsWogjDuRLP9afpbgyyKOGNlHaO8RvyTuQlLl7ePCcjpzqnBruH84xUNhrHGnQWSmUkQaAxouI6zPgcN5sMJAuU8eI6qnpFRRZ4qT/Nmd2NgMueEZ2OhiDZokUoIJEtlpFE72bumd4UG5Y1T5qNdqoxJynd0WiUW2+9lfXr19f8+Ouvv85f//VfH92RHiGmafJnf/ZnXHDBBXznO9+Zk+9xIlIwy5yzuJH2WABVFieKhFsiNIa8ROSZEgspDOSMSTNYHtg2xGUrW0nppv817TGvqMmXbWKyl8PjFTcuScNzHT5cRILjel44mizxxbeuIRKQOD0RwhAV8qaNgI0qi5U1cW+k5SLQFtV8XxzXdbEREAVP2yMKkNa9YM5YoK6XP1L2pjwfGkkQCAUkBrOGv7YN0JvUOb3TG3Pqpo2mSKxqj07qKF2nzpEgCcKUBp2GaVO05pc2LhRUSBZMsoZJOCCTKVpENImOxiAC8HxfmlLZYWlLGBeFTOVmsaspSNFyWNEeJVO06kXNUXJUZ/Nq3tMb3/jGmh9vaGjgKBo/R8UXv/hFAO699945efwTlaJlc/WaBRzIGTUDLL/98E4+c83qWctFWRAPsnMoP+FjumnzYn+a0zvi/jhCUyRimozjOGR0i4aESqpgkq3ctZQsB1GAolmeNCKhJRLABcKyp8c5Z3EjEbdIQQhx689fmhDE+b/+eC1hUaDguuTGbHQJQFjxvC2SBW+Vspo0vqB+wT0iBrOGf+Jd2Bjkwe1DnN/TRE/zwbXtS1e0Ap6GpjFU19DUmR3iIYUDOWPSjz+wbYhNq9qO4REdnnhIJWd4o/BDSeZLdDaGaI9pDOeLqLJMRJP8OAVRsAlW/GzqHB1Htf103XXXoWmTr2G2t7fz+c9/fsYHVefIaQmr2LjsGi4wlC2R0k2GciV2DxfobNI4Z3EjhjV748CuphAblzV7UQsV9mcMfvTEHj71plX8n2f7/e2o7sYgad1gd7JIVFNoi2msXBDjvJ4EqxbECAUkHtg25N+B+cefLbFruIALNIZVFrdEWJgIEw+plCwHQwxx6/99qWYQ52f+70sYeMWeixev4OK5fAoClB2XxlCA53rTRFQJnBJ1Ds++UZ3RgknWKPtF6wv9aXTToX9U56ZNp/naLcfxnKxXtMfqBU2dWSEeUmmLajVjvHTT5oX+NJo8tUP68WBhU4jOuIbjeBuqoiDQEtFIRAJ0xDVc16UlEuR7j+6iUCrzXH+aiCYR1RT0yvZmnaPjqDo1N95445Qfb2trm1dFTalUolQ6eNE6nND5REQQBIYyBlsOEQovag5jWg5XrmknVZjdav9wVvWSCO0xjRf2plmxIMZP/ns7f3/N6gmPo8lTuwm3RSfe5eeMMi5MGcSZN21iqkzWtP3tqZDqPdXThkmp7HLO4iY0YMiafyfC+ca+lM5/vz7M0paI70PT3Rj0jfVWd8RJRAK+FiqgiMTqmUt1ZhnHdTmrq4FR3RonFt6ydZAbL1o6bxPZuxJhVMXwu9SiIBBSvfOObpW55+FdfPCy0ybEKWiKRLz+Ojpqjq239CF8+tOfRhCEKd+2bds27ce/7bbbiMfj/ltXV9csHv38wHJcfvD4Hj62aQWbVrYRVmW6GoNEAwov78sgCyINodl/YSxsDLGwMUhzRMWwHNrjGh+/YiXtsQAxTSFXsgiqMnds3s6n3rSqZhyBIFDTy6TqJuzUGGWGAxLZwyTy5gwL2XGJqhIt0QCiAEPZEplSmYim0hhWEYEBvUhQqRc1U5HRTXqTup/lVPWhaYl6OqpNq9p8cXdAFukb1WkMKvUOTZ1ZxwWyhkVvslDZovQ0fZtWtflBkpkxer75xNgudVNYRTdtBjIGIPKBy5az+dUBvv/4bm65ejWtUY2X+jMkQkpdTzMNpq2QfPrpp3nwwQcZGhrCccYLtG6//fYjeoy/+7u/4y//8i+n/JwlS5ZM9xC55ZZbuPnmm/1/Z7PZk66wKZVtPnDpMl7em67pUzOYM1g8R2uBY9fA9ycLiHimdgZQKNl0NAT5+zetYmGN7z+Y9YqY6oVx7LZM1U04oEwUN4dVecoNPPA8bdpaIuxLFlBcEBUJx4Vc8eBdku24mLaAepgE4FOZavxAekwReagPzVgNTUNI4ZxFjfWCps6ccLhXqgAM5Urz/vnXFtNwLZuoKpEzbVIFk0tXtHH16QsYyRuAwLmLGzGcutXEdJhWUfMP//APfOYzn2HFihW0tbWNu8gc7oIzlpaWFlpaDrWBmz0CgQCBwNxF0s8HREGgZFrjhLZRTSakiogC7B4p0Bad+zTYjkSYvSmdvFH2xbnRKQIjUwUTWZ76uVLrow0hBbHIlEGcUe3g09oVBG8bqqqtccG0HV7a623s2E49w7kW1fiDXKk8Lsup7kNT53ghH+YGxMYdF6Y6n8mUy4QkGQEv3iZnlHFcicaQRkAS+PqDr/PBS5cf78M8IZlWUfO1r32N7373u4ftsswmfX19jI6O0tfXh23bPP/88wAsW7aMSCRyzI5jvqFJImokgFHJVBIFG0kUiAcVNFkkHJApmMfGMfdoEq+zhuXPlSej1jksHlIxTZsvX7uWW3/+0oQgzi9fu5aFjSEyukneKhOWZWRRQFNEXGQKpTIxUeb0jhiZYomm0Mld9E6HavxBdyJEQ1Dh4deHx2U5XbTcuxHpH/WynPaM5Ll4eUu9oKkzp7iuS3NUY9dwYdz7BaA5GuC3rwxwyWmtx+fgjhJVlHh5IMPpHXHypo1T8XgrmGXuftTT2BjleqdmOkyrqBFFkQ0bNsz2sUzJ5z73Ob7//e/7/163bh0ADz74IJdccskxPZb5hCII2IKA4ziVVWmZ/ekiP322n09etZKoKjOYn39z5qimsPnVA5zf01Tz44LgdVVq0dIQJKOb3HbtWvJj1rbHdoaGciUUSeKlgQxrOyrxEJXHsx14bTDL2oUNROtCvAkM5Up+/EFrLOD70IwVBldDBf0sp/pafJ05ZrhgkgipNe0f9o0WeWZPiqtPX3C8D/OIkEWBprDKgWzRNxTM6J6PzdvPW4QguNh2vYs8HaYlFP7Yxz7GN77xjdk+lim59957cV13wtupXNAAlAV4fFcS23UJByTypTLNkQCfuGolX9vyGgjCvFTQh1WJFysrwYdS3XxKFiYvxuIhla5EmFVjVsTHdorSRcs/cQxkiwzlDBxcyo6L7Tq0x4OoolDvLtRgbPxBybJ9MfdTe0a5adNpXLG6jUhApqc5TFdjsF7Q1DkmBBWJX70yQFxTyBbLvv3DozuS3Pv4bt5/8dLD6m7mCyP5Eu2xIHtGdEKqjOt6N3K2De2xAF9/4PV5uaJ+IjCtTs3HP/5xrrnmGpYuXcrq1atRlPEXzZ/97GezcnB1pmYoazCYLXLGwjiG5WJYNuGABAg8szvFBy5bTsGyWRCbe03NUeO63HL1am771ausGnPnrykSFyxt5rdbB9iwdPp6q5AqgevSHA3whz0pViyIjTtxLIhr1E8ZE+lPFgipkh+BUY0/qIq596a8kdNg1mBZa4SO+Dx8btU5KQmrMs/sSbGqPT4uEmZdVwOdcY22aICRgsmi5uN9pIdHVST2juqcvaiJomWTNcpENG+78N8e3sH1F/QcVkNUpzbT6tR85CMf4cEHH+S0004jkUiMW5uOx+OHf4A6s4JeKhPRFJ7rS5MslBjVTYbzJi/tS9OdCJIqmAgwL7sRwwUTVYQbL17ClWvaCKkyXU1BJBH6kjpP7BwlNIN1a02WeK4/jSIIdCVCCIK3kRUOSBjlMoLrrcPXOcjeUZ2sUUZVRD/+oGUSkbkgCHQ3hublc6vOyUlDSOH9Fy+d1ALi168MjDMFnc8EFYkfPdVL2XV5cW8a3SzTP1oE4OLlLXQ2aCQLdWPQ6TCtTs33v/99fvrTn3LNNdfM9vHUOQocIKNb/OKlgXFmdBuWJfjQpcvoTxY4Z3FtzcrxRlMkepNFmqOqH5Cpm+MDMsMzyGQSBFjQEGQ4bxAPKmNE1CLxoErRLhOU6plPVfaldDJFz0wxisTSlvCk8Qf11e06x4N4SGVBTJuQE9ebLGCWHZ7Zk+LK1SeGpkYErr9gMXfcv50/Pbtr3CZhTyJMf1KnMVJ/fU2HaZ3Vm5qaWLp06WwfS52jxHXh+4/v4YYNPXz6TSv9de7BrMEPHt/D316yjOIsRiTMJposcd/TvXzs8hX0JQv+SaraSu5s0Gid5tisasAV1WRe3ptlxQIZLygBTMtBU0RyxTLtrXNvbDWQ0ik7Lg6enXuu6IVoRjV53mhRBrMGvUkdQRCIaF50xfk9TX78AVTCKWXP4bSe51TneHGiugofilG26YgHubjGJuE5PU386KlePn3VquN8lCcm0xo/feELX+Dzn/88uq7P9vHUOQosx+Zjl6+oZC0dzH0ayhp87PIVyKJ3Zz3f2JfSEYSDdyqtMY3WWIDGkEp7TGN9TwJnBqOhwWwJAcgbFmsXxnAc76IcUiVEEV7am6ElMvcX5v5kgWLZpmQ7fPG/XmHzqwcIBSQkSSCtWzy9e5TXB3PH1QW1f1QnVTBJVxKEh7IlX8BddlyGcyX2pooUSmW2DmQIB+R6QVPnuHEkrsJVY8/5ymDWQJUlnu9Psb4nQXtMozGk0hoL0BrTuH3zdt5zYc+cOMGfCkyrU3PXXXexc+dO2traWLx48QSh8B/+8IdZObg6U6NJEsN5gyU1jPcyeonmiIYizS/dSNV2vzXuxRcc6nmyeyTP0pYIrdHp+8dkihatURXHhRf3Zli5IEZIlfxuw9qF8TnPB9mX0tmX8Wbk3354F+8+fzEhVaRQKvPi3owvcsyVyjzTm+KS01pYcIwt0fuTBR7ZMcKy1igBWWQoW6pYAXiOwYcKuDcua6araX50l+rUmYxUwfSft/ORVMEkpEq0xzWG8wY7hwu0xTRSuklAFrl4eSsd8Xo3dLpMq6j54z/+41k+jDrTQQLaY0Hypk22aNEQUrBsh/94qo8PXrYcAWZUHMwFQ7kS6aJFLDj1U0+aQR85pEoUzDLN0QC7hgsM50r+/H33cJ7zliSm/dhHStYo+5qg1R3etoYsCixKTCwKXNelP6UTUqVjdiLbO6rTl/I2SMKqxMOvD7NzKMdNm1bwtUMcg9tjMjFNpmuO4jbq1DlSDncz4uKSNea3q3DWsAgpor+ZeXqnt1xTvela1ho5vqGMJzjTKmrmUxL3KY0gsC9TJByQcVywHRfdLHPTptO4c8tr3LRpxbyr9tNFi4As+rqNWggCxGfQeg2qEs/sGaWnOVTTqCtVKLG8NTrtxz8SskWL6gRtXVcDAG2xAIVSbXdn13XJ6NYx+XvtHfVEwVVL+YAi8ur+DNetX8SdWyYKF+sFTZ35gnSYNef+ZJG2eW4zENUUepNFOps0fzOzen4qlMrYTn2BYSbUC8ITlMF0EUdw0WSZgmETCUi4LvQndcquy40XL0GfhyLhkOqtWr8whfFeZzw47Yv7YNZAFryOiOPCruHCQb1RtsTuYZ3W6Ny3dmNBhYgmEdEkyo5LcySALImIgshZXQ0sSoRY1BTipX1ptmwd9IrSySyUZ5G9ozp9ldXtgCwSkEX2jha58aIl3PdkL0srxV7/aBHHdREF4YRZk61z8lM1rTu0tBGApojKT57pI3KY+JXjTViV+PHTvUxmGKyIAkV7/p27TxSmVdTYts0///M/c95559He3k5TU9O4tzpzT8l2+P2OZA1/mhAjuRKRgEJuHrZhNVnyuwK1/CY2LGumcwa6jVTBxKmY7vUldU7vjNMSDdAUVkmEA1y4LIF7DPxpIqp311Wyyqxoi1Aoldk1XCBXKvOrlw/wD7/aStawOL+niXefv5h7HtnFXB9W/6jOSP6gKPi5/jSDWYP/eKaPRCTA5avaWNfV4I/q+pIFwgGJlnmsT6hzaqEqEg9sP8CGZc0TBLZ3bN7OzVesRJHm9726YdvcfMVK7ti8nULpYPEiItARD/LC3jSqOL8Ls/nMtP76X/ziF7n99tt5+9vfTiaT4eabb+ZP/uRPEEWRL3zhC7N8iHUOJaObHMgUmewa2Jv01ohj2vxTzwsCfldgdUfcv4jGgwpNIXXGqdlZw6KMy2i+VNN0byhrHLaFPVP2pXQMx6YrHqQtGmRf2iBdtNAUiT/0pfyi7p5HdrFzuMBApsjqjvicBtj1Jwv0jeoYlu2Lgrfuz7AgHpx0C+2i01roro+d6swjQorEo68n2TOikyt5xXnesGmNBbj+wsWookBmHt7MjcW2XWQBrr+wxx/zRjSJXMliMGvQEtVqhvnWOTKmNbz793//d+655x6uueYavvCFL/COd7yDpUuXcsYZZ/DEE0/wkY98ZLaPs84YMrqF7cIvJzHdW90Ro2jZNEfml0i4P+ml64oCvu3+WAMtWRQIKDM75qimsPmVA1y5pp2ndo36/je6KTKUNThvSWLOQyyzRpmIKuEAfakimRoFTbWoq25ptMU09Flev8/oJlndAuHgcSxsDPLozhF2DuX8Laczuhr420uWAaCXbJrCdS+aOvOTcEAeF6xavSlyXO+mqDepE1Dnd6cmIHnngtUdMQzL9cN7Q6rMtoEsi5vDlJyJo/k6R8a0ipoDBw6wdu1aACKRCJlMBoA3v/nNfPazn529o6tTk7Ljcs8ju1jX3cgNG3oolR3/onnPI7u45epVpAsWbR3zZ2wwmDW8bZv41EXLTG9QQorEs3tSnL6goaZI+FiEWOYNi7Aq8eiOkXGrpR1xjbO7G/nhE3vGnZCrNMxisTWQLtI/qhPVPBF5piLQBsaJgsduOcU0mY64VhcF15m3tMY0iqY9wVXYM/AM8LH/73l++L71x/swp0QSobMxSKZo+evcowVvndt2oCUSmNOu7cnOtIqahQsXMjAwQHd3N0uXLmXz5s284Q1v4OmnnyYQmF/dgZORkm3z7vMXM1DxQalSvWiWK+Oc+USqYJIpWsTncJU7o3t6mluuXsVtv/J8VsbeyXU2BGc83joSmiMBRvNFLliSwCg7ZCsuwstbwojAxuUJFjVF/BMyeFkws7V+n9FNHto+jIvLokQYURDGBVSOvdMFTxQcDyqIokBsnj1v6tQ5FBEm3LAAvOPbT7CyPTqjzLhjgYCAIAjsGSlMWOfubAjyXF+KM7saj/NRnrhMq6i59tpreeCBB1i/fj0f/vCHede73sV3vvMd+vr6+NjHPjbbx1jnEERRQFPEScdPoijQFptfxWXWmPtV7qFcCUGEVKHEjRcv8U96rTFPtDucM47JSC4kCsiRg/5B8aBCWJX4ydN9vO2cbi5f0c6OkQLxoEJvsoAAXHxay6x1kAazJVorf/9M0aKrKchjO0d4dX+Gs7sba47/+kZ1ljaH6yOnOvOesuttE37h/73Co2POfxuXJfjCW0/HOQZbhDMhVTRpiwbYOTTeQ2vXsGc82tkYqmtqZoDgujN/Bjz++OM8/vjjLF++nLe85S2zcVxzQjabJR6Pk8lkiMVix+R77k3p5Iyyf7ceUSUUUaB9Brk/e4bz/H5X0r8oVUdP3310N+u6G/if/+N0lrREZvGnmBmDWYPRgskvXxrg1f0Zv8s09qI6lDW4YGmCxc3TP+6n94wSVDzX3mpbt/r4g1mDpS0RFsQ0upvnbryyP1lAccEQ8Iua6t9dc+EHz/Tx5rM60WTP4ThXsuiMB2e08TWW/lGdAxmD4byX8FvtBN33ZC/vqGh5agVU1jU0dU4Udg3nSeYNbJdx3ZpCqYwkCCQiARJhdd4+n3cO5dmfKtISUzEsF6PsRbgAbBvIsigRnvPz1InIkV6/Z8Xl54ILLuCCCy6YjYc6oRlO6ZQcF8txiQCIQs0NJcl22TdSQJVFWqZhje9SWyR81zvW8ZEfP4cxz/xpUgWTgCSydcwq9+pDLPjPX5rAtGcmjgupElu2Ds5ZJ+hw9I/qaI6LIQokCxaG5W1dlW2XJ3YlOa8nwfXndjNi2uiWTUSV6GiYvWKiGntw5sIGv5h5rj89ThS8uiPO6R1x9qa8kVN3Y7CuoalzQiGA70HVNmYRoHrj4uAylCvN26KmOaJy+/3b+eim09g64C0zHNTUuLRFA9iuy2DWmNdxD/OVacvEf/jDH7JhwwY6Ojro7e0F4M477+Q///M/Z+3gTiQOJAuUbJey6xLBAFGg4MKnf/4Sb/raI7z920/wpq89wi0/f4kCoLouJduhL1k4qkDDjG7yuf98eVxBA/DYjiTfe2w3N2zsmfUtmpmSNcqU7DKfefNqflxjlbujQeOuLa8RD87sJKTJ0pSmfm1zaLqX0U0yujmhoAGBrQMZuhMhDmSLlICcYZEzLLpmcdwzNvZAVbwT/GDW4NX9Gd52dpcvCr5yTRshVWZRk2f+Vy9o6pxoHG40Y5i275Y9H4mHVD5x5Uq+dv9rNcN8kwWvy5oqHL+g2xOZaRU13/zmN7n55pu5+uqrSafT2BX3w4aGBu68887ZPL4Tgr0pHQdwBXh8ZxJDDGIAt/7flyYUH4/uSPKZ//sShiiQM20e2zFCtmhxIF2s+diHMpI3ebYvzYcuW8Z33nMO//rON/DdvzyXD122jOf60qzraph3IuGYJrM/XeJbD+3g829Zw5vWtBNSZbqaghiWzVd/s42bLl8x47uSqgdOLVO/s7oa53TWPpQrEQnIPLpjZIIhYjXvqTepYzouUU0hOoseQmNjD0plh5Jls7QlzNKWcE2nYNd1aQgpLKyHU9Y5AXFdEKZYKHhg25A/zpmvSAJ8+I+WkQgHfB8t23V5pneUsuPFQcz3DKv5yrSKmq9//evcc8893HrrrUjSwSfPOeecw0svvTRrB3eikDPK2ECyYNEa08ibNnnTnlDQVHl0R5K8aZMzDn7+nlH9iDo2+ZLFXe9Yx3N9Kd73/Wf4wL//gRvufZrn+lLc9Y51SIIw70IsY0GFnz7bzw0bl/KPv97Kgazhm2a1xzRuedMqZmqnW/3dVUWwY51xe5MFsoY1qVnhbODiUrRsuhPhcTqnagRCb1Jn5QLPPyiiSrNWeFZdgsfGHjywbQjwvmdUk7nl6lW8aU07UU2hpznM0lZPjFinzolIsmDSEgnUtH/QTZsX+tPzvqgRAUUW2TqQoVAqszdVZDhXwnY8N/R8yZrVG59TiWkVNbt372bdunUT3h8IBCgUCjM+qBONbNEib9oYlk2pssKbPUz7M2d4T9pS2SFXtAgHJAazpcN+r4agyn1P9rKuu3Fcp2ZddyP3PdnLokRo3s2Si1aZT161iq9t2c7bDglLjGoyI3mDmVpNDWZLOIcpW+ZioWBvSmfrQJZUwQJBoLsxyLnt8gTn4JULPGGbXrKRgI5paKkOpT9ZIJk3MSx7XOxBdQRXdlwGsyVeH8xzIGuwcyhHLCDX5/R1Tmg0VeLXrwxwVlfDuFyy/RmDHz6xh/dfvHROXuuzyYheQhFEelrC/vipNRagpyWMLAjc8/CueV+YzVemJRTu6enh+eefZ9GiRePe/5vf/IZVq1bNyoGdSMSCCtmiRSggUTDFI/L6iGreRkxAFokGFdK6hSE5HEgXaZ/igmc5DtdfsJjvPLKLu3+3w3//Rcuaed9FPcckFPFoGS1YRAIin7hyJUXLIWd4a86KLPDMntFZWWHMFC2Ch3ESne01yd5kgb//+fgR48ZlCb587Vresw5e6GrwnYPBu4tsDCl0zIKOZW/K09BIgkAoIPmxB2d3N47zoakWMEFF4uLTWuodmjonPCFF4pk9KVa1x8dtUa7raqAzrrEgpjFSKLGo+Xgf6eTIksRAWqezMUTetBEFG0kUCakyd27ZzgcvO23G3etTlWl1am6++WY++MEP8h//8R+4rstTTz3Fl7/8ZW655RY++clPzvYxznuimuwXMoNZg4gqEVUlNi5L1Pz8jcsSRFUJDRjKGgQVkYgmEVKlIxpDfeeRXTxyyGjrkR0jfOfR3fPyDiWsSmx+dYihnMHz/SnypTJ7kgX6kjpG2UEQPEOqmRAKSP7YpRYz8PSryd6UPqGgAW+0eOvPX8IQQ5zZLPqiaN200RSJmCIdlTC8FoNZg4zuaWhCAe9u7v88288nr1rFj57Yw1N7Rrlp02lcsbqNSEBmaUuYNR2xekFT56SgGpUwmXauL6nP62T5jG4SVCTufaIXw3bIFE1CAYmMbiEI8PbzulHrSd3TZlpFzV/91V/xla98hc985jPous51113HN7/5Tb72ta/xF3/xF7N9jPOehY0hoqrE9oEsS1vCaE6RgAtf/uO1Ewqb6p18AMAxuHBpMy/0pymUymiyZ+V/IGvU/D4AtuNOKGiqPPL6COV5WN2HVXnKraSWSIDRGV7og8rhN5+Ss7hNkDPKh9VMlcQQV65o8jQ2skRzSGGwYDCSn/5x7BvVGS0c1NCA521x/QWL/Q2ny1a2UijZSIJASzRQ96Cpc1LRGtPoiAdrpsrLssB9T/eiyfO3qBnKlTDLDu+5sIfbayR1t0Y0nutPEZRnxXHllGPav7V3vvOdvPOd70TXdfL5PK2trbN5XCccCxNh1gMDmSIP7tG5dLFMSFT4x2vXkquIgqsjJw3AcUnaMgXD4PSFDYzmSyC45A0bWXToTxZqrttmi+UpjyNrTP3x40FDSOH9Fy/l2w/vnOBPc1ZXI79+ZYDLVrRN+/EzuolU2Xw6dOwy9u4tEZ29C/thNVOVjzdEQuSsIomwggIEFIXcNLca9qV0Hn59mCUtESKaxGM7R+huDPrbVRctbwG8DaeALLJnpMDFy5vrBU2dkw7XdVnfk6Bo2V6AbCUq4fbN27n+gh4EwTsvzMfnfrpoEVJFwgGJi5d7183qa3b3iOcqvKAhSMMcemqdzEyrU3PZZZeRTqcBCIVCfkGTzWa57LLLZu3gTjS6E2EWNoY4Z3ETQ5bAnmyJgmXTEdc4rydBQ1ChYNnsyZYYMm1UUSIeVnmhL4XjQn+y6I2hAl4Y4mCNjk113DAZ81Vc1h4NTLiz6k0WOJA1eGZPakbjoaFcieFc6bB3b2F19u58Dqebiga94iVv2ixsDCID+/JFbzQ5ja2GjG4ynDNpjWkE1YMampaoV7z1JnVO74zTEg3QFFZJRAK88bTmWXMqrlNnPuEAw3mDF/am0c0y/aOeJcZFy1t87dxQ7vCLF8eDkCpxIFPimw/u4PTOOImw95ptiQY4vTNOX7Iwp55aJzvTKmoeeughTHNiC90wDB555JEZH9SJTGdjiCUtEdZ0xDm3p4kV7TH/ybmgIUhIkdgxlONA1mDbYI7eEZ1S2aEpovKTZ/oolMpeuGHFZfJQNFliwyRanQ3LEvOy7TqSN9GtMms64zW3Fa5bv2hGHjLpooWqSPx26wDrexK0xzR/m6A1pnH75u2858KeWbvzGa7opqbSTFWLl5xhgeNiOi7N4SBF26Y5cvQnqwNZw9+ug/Eamid2j/rbVcWKGLknEaKjrqGpc5JyuAuXi0t6nhrwabLE/3m2n49uWsGdW7azZdugv9adM8qsX5LAsOdfx/1E4ahuXV988UX//1999VUOHDjg/9u2bX7zm9/Q2dk5e0d3EtKdCCPgjYnGtk3v2Lydm69YSapQQhLwVr0Ni30pfZzAUxDgQ5cuA6gRZrl81gWxs0GmaCJLIndueW2cm/C6rgbAyyX6/JvXTPvxw6pE2XF5Yucoy1ti/kZESvesxy9e3sKCWdKV7E0WMB2HqCjy5WvXcuvPX5oQqvfla9eiOTqo3t/NAUzHIShJhCTpqI+jf1QnrR/crntw+9A4Dc3YFfmW6PzOvalTZzYIBWTITf7x/mSRlnkW6ltFEOA9F/ZMeP22x2SCisRzfSnOqqd0T5ujKmrOOussBMGLTa81ZgoGg3z961+ftYM7Wal2KwRBIGdYLIgH+dgVK3ixP8WZ3Y30Jb35alRTGM6bRALyuIuUKMA1axdww4aecYGN8zXZNaTK/PbVA9x40RLufnDHuFX0DcsSfPiy5TPqomiKxDN7RifX1HQ3UnZn6oTjbR3tzVScn6MKUVHmtmvXekaKRYtoNbjS0dHFECEAVcIFAoKEKIB6lFsZ/ckCyYJFsDJWrPrQnNHZUENDk+fi5bOX9l2nznwlIIu0x4LsGh7viyYATRGV2zdv5+NXrDw+B3cYBCAelOt6mjniqIqa3bt347ouS5Ys4amnnqKlpcX/mKqqtLa2jnMYrlOblphGf7JA1jAJB2QyRYuIJtHRGMTF5b6ne7l4eQvLWiJkipYfzpbRzcMuPs/Tusa/EB9ajA1lDdpjgWlfiDO6iWU7LE6EcXHZtKptXDp3X1InHpQRZiG7dbTg/b0ARvI20YiAJkpQKTiq4mDUSkEDBFyXggtG2SaqyrQchfHdoV402yrbdT3NtX1oLlreUtfQ1DklGMmbCMLUYuH5eJM3mDWQRIG8YbGuOz4upbslGmD7QI71S5rqNyYz4KjO9FWzPceZ+V3vqU51s2nstlKhZPP933svyNZYANt1CKmSPxseyZso0tSvVEkU2JvSWTiP9BQu7qTp3Gs64xjl6fsxDOVKWLaDVlmpP73zoNGdJku0RjW++dAO/uHatTP+OXJFC7si/YlpMmlXQHF0ZLHyu67xp+nNGSQiGlFVpugc+Zx8rBfNwsYgD24f8tPH+0d1btp0GuD9nImwRHNErWc51TllyBoWiiRQKJXZWUnrro6bx4qF5xupgklYkWiKBPjDnhQrFsQIqZJ/vjpvSdP0U6brADNI6a7FwMAAfX19s/mQJzWaIiGJ3gWyaDq0xzT+7ooVSKLLaL7ESN5T74dUqdLZsZCA5ujE3BOh8n4Jz0NlPqFKku+sO3Yz6fFdSe7c8hqKOP3uXrpo4bjwzYd2sGJBjJzhCe4KpTJbtg1y55btfPKqlbNy5xMNKkQ0iYgmEVBEXupPU3Y1Pv9fr/DLlwbIGWV2jxToSxW97ozr8u9P9uG68K2Hd6IKR3YP0V/Di6bqwVPNkIKDhVsiXA+nrHNqEdOUqc02AdN2Zmx0OdtkjTKm6yAAXYkQgoAfaGmUy9iOO6cZdacCs+ruc9lll/Haa6/5qd11pqYlplG0vKTu1pjGSL7kj2TOW5JgNF9i20CWsxc1kTXKhFQJAVAEgZ6WMOGATN7wcn/CAQlF8Hx5p+uDMleIFQ+ZWnqaD126HFHwOhPTySQKqRJbtg5WhLPjhcgXLElwzdoFNMxSeGRIlRjIeCfJolmmszFIqlDixouX+H+L1phEoWQjAk/sTnHTptMwyjZvPrPziObk/ckCj+wYYekhXjRj9UKJSIBS2SEeVAgoRxbLUafOyURzROWlvRnO6GyY8DEBCKoSjuMykp9fXjUxTea3rxzgqjXtk35OcQad6zqz3Kn5wQ9+wO9+97vZfEgA9uzZw/ve9z56enoIBoMsXbqUz3/+8zXXyk80uhNhNi5rZkE8SCKssiAe5JyeJt+7ZlEijCu4ZI0yiuT9uTyhmYIkiogCSKJIPKj43Zv5lu4qCYIvbq6GcH7nPedwzdoF3vELAqlpuv1qsuckbFjOhHTuvmSBkHL020aToYheAnprNEBzJEBzNMCeEZ2QKuO63laDbUNHXGPnSIGmiEq66DlFdzUED3scVQ1NWw0vmlrp432jOo1BZV6dtOvUORbEQyqfuWY1P6oRlbCmM86/PrQDRRbn3Q1eSJV4dk+KvaO1XeMd3Hrk0wyZ1aLm3HPP5Y1vfONsPiQA27Ztw3Ec/u3f/o1XXnmFO+64g29961v8/d///ax/r+OCC6LgEpAlsoZF0bRZ1halN+kp+w3T68aMFkp45UrtgbEgwL60TlSbX/bajutOOTJzXJfsNE4++1I6QqULNFkOzEz8bw6lozGEIoqMFkrIgoAqipy3JIEiiRiWTTyo0BJW6B3RcVyXUtnxvWUOJ+Adq6GZzIumaq6XCKssbAxy9entU4af1qlzMiO4Lh+/YgUXLElMGGlff0EPe0eL8+4GbyRf4rNvXsP3H9/NozuSDGVLpHSTbLFMW0zjGw+8TnAe51adCAiue/Rn/f7+fgRBYOHChQA89dRT3HfffaxevZr3v//9s36QtfjqV7/KN7/5TXbt2nXEX5PNZonH42QyGWKx2Bwe3dGR0U22D+bYMZQft7kzmDVY2hKhL1mgKRKgoyGIKDo0yQoGeKvEY+IXSraBKml0z0IK9GyyN1lgIFvEdhk3MiuUykiCQHtMI2/aNIXVIx5BZXSTV/ZnaY9rDOcMXyx46O+uJRpgSUtk1n6W4XSRku3UjL6wgYJT5sldafZnDNZ1NdASDVCyHM6tiHxr0T+qky+VSesWuunpoV7en+G8xU384PE9/OnZXeO8aIKqVPeiqXPKs+1ABlWSeHJXktYxr/2hrME5PU3cef9rfO4ta6Y11p4rtg1kSeVLdDaFyI3xKhvKlvjps/3cfMVKFAEWzeI562ThSK/f0+rUXHfddTz44IMAHDhwgMsvv5ynnnqKW2+9lS996UvTO+KjJJPJ0NQ0+YXiRCIeUulqDCFM4px31qJGfvpsP0FFZDRvs79QQsLTqggIOK6L5bgEleC8K2gABBdao0F2Dxf8O5OhbIndlULkhb1pApJ4VCOooVyJdNHicLK62d4kaGkIIsFBx+CiF4VgAI4L6UKZBfEgr+7P+DEXU0Vb9CcLPPL6MNnKWv9z/Wnfi8awnHFeNLpZ5sXK76pe0NQ51VFFibseeI1zepomuIjfsXk7n7hy5bwcP/3wyV7vxqjkveY9LV6A6y9cjCIKGPXt4hkxrXP+yy+/zHnnnQfAT37yE04//XR+//vf8+///u/ce++9s3l8NdmxYwdf//rX+eu//uspP69UKpHNZse9zVcWNAS55LQWFjYGaYl4ycrn9TRRNG3fbbiaDSXLErtTRRpCKuf2NLGmI86Slsg45+H5RCSkkCmWWL8kQUdDkOawSkdDkPVLEiTzBms64pTs8lGNoNJFi4As0p8sTvl5ocDsjuIyuslTfemD76jUoS6QsSwe3Znkh0/s4caLlrK0JcK2geyk7eTBrFFTQ7MgHqw5UgsqEhefVveiqVMHQBYF3n5uN7f9aiu/fuWAnwGlKRIfvuw0dNMipc+vomYkX+KTV63ijhrp3B3xIP/60OvzMurmRGJaRY1lWQQCngX1li1beOtb3wrAypUrGRgYOOLH+fSnP+07FE/2tm3btnFfs2/fPq666ir+7M/+jBtvvHHKx7/tttuIx+P+W1dX11H+pMeWajaU7To4uAznTBJRlesvXAyCy4+f7qVQ8oSnmaJVMxtqPhIPqTSGNZ7rS1F2HBAEHMfFdSEaUrnrgdfYny4d1fw7pHpdjf94po/GcG29zoK4Russtp6HswYHsgYRTWZv2iAgC7RFVCKqxGjBIlO0uXRFKzdtOo3+UU8PtSgRnrSoGS2Yk2pontozyk2bTuOK1W1EAjJLW8Ks6YjN28K1Tp1jjaZKSKIwQUDfW7G/uH/r0LwL+A2pMgMpnU+/aZU3dq+M4g9kDf7x11u58eJl1JXCM2NaRc2aNWv41re+xSOPPML999/PVVddBcD+/ftJJGqH/NXi7/7u79i6deuUb0uWLPE/f//+/Vx66aVceOGFfPvb3z7s499yyy1kMhn/rb+//+h/2GNMVyJMZzyIOOYyXSjZ3P5br1sjCQIILoGKsr8/WZji0eYPMU3mvMVNZItlRvIlDmQNfv78Pm775Vb+9tLl/PTZfkJHKJDL6CaaLPHq/gxvO7uLO+7fTmtMozUWoDGk0h7T2LiseVZHcV5cQYm07hUhEU2iL1lkKF8ipRdJhBU02TPRAli5IEZfssCCuMaCGmLe/mSBbKXbFJAn5jldtrKVQslGEgRaol7nrj5yqlPnIJmiRWuNBQTwPJxe6E8TnGddj6gmH3b8VKxbosyIaQmFH3roIa699lqy2Szvec97+O53vwvA3//937Nt2zZ+9rOfzfqB7tu3j0svvZSzzz6bH/3oR9OKY5ivQuFDGc4a5Etlipbji1EVWeCl/jSdjSEEweXh15Ncs3YBjuNtFs0nMVwtXjuQQ5MEEIVJBXKyAIuPQCD3+mAOSRQYzBq+d0v1Ti0eVGgKqWiKSM8sie0GswYPbB1k9YI4ogjDOc8U8afP9nPT5St4ds8o3Y0hOpqCGJbj50DFgwodkxQ0fakiTWGVX740QEdcY8vWQd59/mI/jHOs6PHievxBnToTeHr3KOGAiIDAaGVzMCCLPNef5tX9GW68aCkd8QCLmueP6Pa1wSyqJPFPv9nK2w5ZAIhqMnc/+Dp/88Zls7rccLJwpNfvaQkOLrnkEkZGRshmszQ2HkwTff/7308oNPsn33379nHJJZewaNEi/vmf/5nh4WH/Y+3tk5sYnai0xDSMZIEX+lO0xjSSBc/+u1R2aI4G2DdaZOv+DH/6hk4GMiVEUZj3RU2maCFGFFJZA9uFiCaPu0NJFUosOMKfIV20aAorvnfL2CKgN1lAFgWCyuwl9I4WTNpiGoZlEwpIDGYNHnl9mJs2reDO+7fztrO7iIUVDmRKxDSZBXHNj8E4lP3pIlmjTKZo0dmgsXV/hrO7G2uGcfoamvrIqU6dCYQCEvdvHeT8niZ6kwe3H9d1NdAR15BEmEVHh1khrZdpjgh8/IqV4zKrDmQN7n6wn+sv6EGerxkPJwjTVlFKkjSuoAFYvHjxTI+nJvfffz87duxgx44d/hp5lWk0mk4IuhJhLhYFskaZXNEioil0J0L89pUBnt2T4parV9OfLNIQUfwx1GQX0vlAKCCx+ZUDXLmmnad2jformLp50EE5eoTOuF5sRJGgOvn0dLYEwoNZg2xF99ISlfwMpp7mMHdu2T5h3ToenDyyYCBdJFO0/PgD3Sxzy9WruO1XWzmjq8HPcyqaNp2NChFFqhc0depMQkiR/KDcQxGAtqjn0r64ZcKHjxsxTeY3lfPgi3vTtI7JrLp4eQutscCMsvDqTFNTk0wm+eAHP8jq1atpbm6mqalp3Nts85d/+Ze4rlvz7WSmszFERJVwcLFdh5GcyUXLW7jx4iW+cHgo6wlss0bZXyGejwQViWf2pNg3atDTEvb1L62xAD0tYRRBOGLNiCZLx0QgPJAuMlowiWrKhAym/lGdv71kGS3RAIWSTVCRiGnypAVNRjd5aPv41e2X92X9mIWqhkYQvADQvGEdcZFXp86piCwKUxpv9iV1tHkmFG4Mqzw7xXnQrTsKz5hp3c6++93vZseOHbzvfe+jra1tUn+VOjNnsjTvH/x+Ozdd7o0/PnnVynk/hpIFYdyIpaqBcVxPA3Okz6CBdBFBgOsvWMwd90/slPQkwjizcFaoFiFLWsI0RVSGsgbJfGnaGUxDuRKtsQCxoML+dNEfOzku7BpjHKibIkO5Epee1lIXBtepMwUjhRId8SCXr2obZ77XlyzQGgtw39O9fPLKlcf7MMfRFtP43FvW8KX/eoVVh5wHOxo07tryGjddvuJ4H+YJzbSKmkceeYRHH32UM888c7aPp04NNEXyLeayRpnWWIC3nd3Fnfcf9K+Z72Mo23VpjQVqnoDa4xrlI+i6VQuN9UuaEAXGGdMFZJHdI3nfRXimVIuQoCpx/6teu3ikIhA+VMfTN6qztDk8ZRFS3ZoKKiI/raxu/9NvvLHTpStaAW/s1BBSOGdRY72gqVPnMKiyxN5RnfU9iXH6FIDbN2/n+gt60OZh5IAMfP4ta/yFidaYtzDx1d9s4+YrVs66YeipxrR+fytXrqRYnNr0rM7s0RLTvPTtGiuAJ8oYygVG86WaLdfRfOkwvsAe1ULDOcxnz0bfMD3GP6Y6NhMEL6tqfU+C9rhGSyRwRBlM/ckCoYDkmwXefMUKvlZjdXtBXKMpNLP4g70pna0DWZ7clWTbQJa9KX3aj1WnznwmKEv86Kleyq7Li3vTvvke4G0MNmgUzPJhHuXY47hQdmqvdIsCHNHJsM6kTKuo+dd//VduvfVW/vu//5tkMnnCuPaeyEzlX3PT5Sv8GIWsUZ63pnzVUcvYqIRdw4UjniFXCw3DnFpIJ83CODSkSr5/zI0XLeHex3fz8OtJ9ozobB/MkdYtIpp8WP+YvckCWcMzTBzMGtz3dC8ucP2Fi/2xWUSTyJUsBLwCdjoMZg22H8gykDZwXZeWaICIKqGWHfadIF5GdeocDbIo+GPoQ32q1vckKJgWqcL8chQGr2s9k4/XmZppjZ8aGhrIZrNcdtll497vui6CIGDXzYPmBNHFT+CuNYbSTa/9Op/HUDOhWmg8sM3bQKqFIEA8NDOBbdXcr5rBdEZnw8SRU7LA4qbQlAXNYNYgZ3ptcU0VWdoSpqc5zO2bPS1QuLKhJSLQGQ9O+vcazBqMFkzf/yakSsh4HSnHhbLrJWCpkkhbLEDZcXm+L0VnY5D2WJCQCwdSOu31Tao6JxHxkMKBnDHpGPqJ3Uk2rWo7zkc5EVEUGJ6km57Ml+atLvJEYVpFzTvf+U4UReG+++6rC4WPIZGQwutDOcqOW9PnZc/IwTTv6hjqZHqBHFpoHIoAdMaDM9ajHMgaSJJQKUJq+8dsWNZ8WEO80YLpbztVV9CrW1OAvzUliQKaIrE3pXtz9qJFLDg+/TuqSsRUiaxpcef9O/jgZctRRQGvW+0yki/5Ha/maICzuhtI5ks8tTvJ+UsSdev1Oicd8ZBKW1Rj51B+wseqjsJvOaPjOBzZ5GR0EwFoigQmtbaoX01nxrSKmpdffpnnnnuOFSvqKu1jSTyk0tkQ4qHXhmmNBvwXw2DWYGlLhLMWNXLH5u186qpV7M8Y83ob6mjJ6CaCwIwLjcMxmDVI6xbhSrJ2/6ju+8fopk0iLKEpIsKYGmFfSid7SDEiiQK5yr/3p4u++/Cu4QLDuZLf8dk9nGfDsmaSeglVlFBlgUhAZvOrB3ixP81n37yGMC4GYLkuYUXmY5tO444tr/H287qJVzau7MpoD7z/9rR4XZ8VC2LkDzOuq1PnREUEzupqYFQ/qIHbnzHYsnWQGy9aiiwIZHRz3gjvR/KmfzPS0xImHJD9EXQ4IHkFTf3+Y0ZMS1NzzjnnnBA5SicjCxqCXLw0MWWad9l1xo2h5gOHu/s43MeHKptHcLDQuGJ1G+GATEc8SFNYxZ6FbkSqYBJUJR7YNgRA2XEZzpXYmypSKJV5dSCD41gIksDrw1n2jBT46m+34boO7XGvwBrIGGSMMtGgQliV+Omz/Xy04j5cK6Nqy7YD/Mm/Ps5n/9/LDGVL5EsW5/c08a7zF/M/f/EKhiCQt2yMssP+rEHBsnnvxiWEAzIuAi4C4YBMW0yjLeZ59IQDsj/eyhUtckeRgF6nzolC2XVRFW8cXHVdX9fVUNmyDGC77rhzx/Ema1h1Tc0cM61OzYc//GE++tGP8olPfIK1a9eiKOM1DGecccasHFyd2kSCCiXHraR5i+PSvEUBnu9LEw+pdDQE6UsVEUSBhcdZTzHToiZdtGgMe8+zaqFR7XbsGvZm6K2zsMqdLVpo6uROpW2xADFNo1AqE1Ik/uX+7Xxs02mUXU/HclZXAwE5wEjepC0WYCRf5JNXreSffrNtQtZLTJNJ5nUe2DrMXe9Yx0d+/Bx3P7iDa9Yu8L/fqo44edPGrfyGqoWMLAlkdAtR8Lowjot/pwqQN7z3CwJ+N6dOnZOR6lbloV2P0XyJxohKujh/CvqYplDGJZWvXWgl8yXaoidHd/14Ma2i5u1vfzsAN9xwg/8+QRDqQuFjRDykUjRtapUCyXyJtV0N3LHZM+XLFC1yRpm9yQILj6Nw2LBtzwF4eHznyJsvqxhle8o2cUiV5nzraW9KJxZSGMmW+Pyb11C0bXoSXjEoCgKO6xIQBUwXskUTx1W5YeMSBnMGkuC1wYdyXrZVQ0hFAhpCAVzX5cN/tBwXbyQVDymV/gq0R0L0JXW+99hubtjYw92/28ENG3r8Y2qLaeSKlt+Rdlz8QiaiSUii12y1HW8UWaXq12HbEFElhHqeTJ2TEEkQahpYVkfyhmkTmkeuws0RlQe2DXFmV3xSTU29UzMzpjV+2r1794S3Xbt2+f+tM/e0NwRZGNdQJRFZFBARaI54lv3VMZRuehlDuaLF3kzxuPrXqJI0YfWyNRagNaZx++btqJLESH7yVXRNlnh1/+R2AUez9bQ/XWTbgSyvDWbpTRbYdiDL60NZRMclrEi0N2jcsWU7qigynDewcRnIFgljUwYe2zmC7XpdHVkSaQoHCAUUnu1N0RgO8P3f7yGsSDy/L4MsiCQLJYKKNy8XBK+Qi6gyOC4Zy+Yb73wDj+1Isq6rAfA6LmPfokHFf4toEtGgQiyoUCiVK8WRS6HkCcMHswZDWYNCqUyhZJMIK2hw3Dt1derMBfGQMuWiyqv7s2jy/Clq4iGVs7sbJ/HsipAuzJ9R2YnKtDo1ixYtmu3jqDMNokFvpdF23QljqFShxO6RAn2pItesXUDZcfy06eOBUvGUuPvBHTy2I+m/f8OyBB+6dDmO4JIv1jbKqoqEFyVqX5gFBNqiU/vFVOlNFrjj/u186I+Wgwt33L+dD//RchRBwMJlIGPw7Yd3ccvVq3hiV5IlLWGe3DUKQEe8mbxp01bRrMii6G03BWQEUWBtVwP/snk7N1+xgoJlc0ZnnGS+SFNYo2g5/kp2QBYZLRgkwhrZfJlwZU2/Oj6q5kyB5yYdUSXyFROxQqlMPKgQUWXCShABT1eQF8osbYkA3vaTUPmda6JAS72gqXOScnADqrZ2cFEijCAwr8TCogBRTamY8LkIApQsh75kgUWJMFK9qzojZhRl/Oqrr9LX14dpjr/Dfutb3zqjg6pzZBxuG6olqvHbVw7wp2/oZCBjIYn2cfOvKZZtWmMab167gBs29Ph6mKGsQWsswG9fGeDK1Qtqfu1QroRceaH3JnVO74wD3jaSJkt0NgTHhZuOXY1uCClEAzKu43m5/OOvt/LJq1YymDX4/u/38MmrVmJYNsNFC032xLWrO+KYluMXL9VCMG/afmJ33rBZ2OB1hnJGGdd1iWoKf3p2F8l8CQGBaFyiORIkVypTdlwcvKLkpb151vckcF2XkCqRNyx+/oELUUSRy1a2+B01Adi4rBnNBRSZsusSjsmIgvfCdYSDm9qJiFfISKKAhKe7mi8n8Tp15oLq61yTRdZ1xzEsF6PsjZtaogG2DWRZlAjj4ImF59PrQZHFceOngCxiO65/Q1Jn+kyrqNm1axfXXnstL730kq+lAfw2YF1Tc+xY0BDkspWtpHWTtG4RrLygH9w+5K8Eb946wAVLmr3OglFmb0o/5uMI23Exy+Wagr59o0X+0JvmbW/oqvm1RyISboprDKd0bMdFBuKqRIMqUQaMso0LmGWXPz27i4xeJhyQ/f9XFZFwQKZg2LgWrOtqIGuU/eKl2kGprmznS57J4d5RnYVNIRzHRaiscLfGPLGyLIo4eHboggCyJCJgEwrIrF0Yx3FdhgsGTWENURTIGV7H55NXrfS7P9GAjAZYlZGVKgiIokCp7DBStIhqCs2RmcUq1KlzIrI3WSBvlQlURkuZosXOiq5mtGASkEXKlYrfMG2KljPVwx1zplzpZn51lk40pqWp+ehHP0pPTw9DQ0OEQiFeeeUVHn74Yc455xweeuihWT7EOoejLaYRUWViQRlZEimaNpevbufjV65g76jOkztHKZTKfoxCRrfI6Mc2SkGVJL7x4A5Cqky2WPZjEh7dkeT7j+/mM9esnnTtOKRKbH7lQM27GAHoqLzfdFxcFyzXW4ssA/syRYZyJZ7cNUq2nHWz9wAAQR5JREFUUnQYlu0bFxqWTa5okTdsQgGJiCZRKnsr8QFZ9P8bkEXfg6aqWfnhk704jkNMkxHwWsp5w3vsiCoh4hU3maKF7Tg4rifozVSEv64roIoCYVWiIagQkUWiikRUU8gZZfKmjQEoisTCRJjORJgFjSEWt0Q4q7uRpa2R+omvzinHQErHdl3ssoUmCiiiMKWu5oFtQ/NKLHxYHxqXebWGfqIxraLm8ccf50tf+hLNzc2IoogoimzcuJHbbruNj3zkI7N9jHWOgM6mEBFVJlUwSRZMBtJFfvnSAb73+93ccvVqWqMa/ckiEU0ia5Q5cIxFw5IA11+wmDu3vMbju5K+p8QFSxJ8/IqVOK5DSq9d1Giy5IdK1grElESBEmA5LmUB8laZfCW1t+rX0hbTvC7LmOKl+v9VAS4c1KwMZUt+8TJUEeBGVO9O6sKlzUgC3HzFCr7y2+3sT+lEVYloQCKmyUQ0iZGsjuqC6noux5IgIgogCSKJSIDn+1K0xTRUQKjEHIDXOm1WJTornjf7MwYjBZP+ZOGYF6J16sw3MrpJ2XHZMZwnpgVxXBfLcWmLajXHNlVn4fkkFj4Sn5rMPFpDP9GYVlFj2zbRaBSA5uZm9u/fD3gC4u3bt8/e0dU5KroSYbobg/Q0h4lqMtesXcBn37yatG7gcDDNO6JJZIvHNs07oEiIAmxa1ca6rgZ/fNSbLJA1LPqSxZp3U1WRcDVU8tEdST8QM1ssE9dUcpZNzrQRRMH3dHERKJi23zkplR0iqld0gFe8VP+/uj20fSCLJEBng8ZPn+3n7MVNSAKct6SJpS1hFKeI4HovmoZwAFkQ+NRVq4iFAxzIGeC4xDSZQqnMtiEdV/BEgQHwCp6gQr5kUbZdzlvcRBBI2/9/e3ceH1V1Pn78c++dfc1CVgj7qqLgArIJKoLaqq212uoPl1JaKwiKdaHaYhdrxX7dW7e2al1ppVXbWkSrKKIgIuAChDUkkED2zGT2uff8/riTkUAIgQQCyXn7imSWTM6see45z3kencaEgdeqoRlh4sI8kNMAdZ93ZyycYE995Eg+TZJ0TKtujNMY1xmc6yUukghFIRzXEUIwoigDh/Xrz5DyhijPryhhxoQBqKlk4WOBqijUtFKnJok4tmaWjjOHFdScdNJJrFu3DoDRo0ezYMECli9fzq9+9Sv69+/foQOUDk1RthuPTcNts1AfThCMJWmINO/mXRmI4bJpR7WbdziRJN/nbHH5KMtjY+GnpThbOJpqmoZtLSAKRMyk4HAqkTeY+nLbzBmZpiWkRGqpqCl48aa+D8cSFPocnNo3E0PAurJ6bj1/KA+/s4lQzEABCnxOIjiwCYFNAYemEkka7AmagWG+14FDVbBjzsyM6p9FTEDAEPxvSzWbKhvZXh0iGE2ytrSOmCFYVlKLXTMrP+uAorhwiChxIAm4LRr9/A4ybBoa5nZwNXH0lw4l6Vhhvt8ThJM6NtXCroYIBgJVUQhEE+zYp7Lw5GF5qKmDiz2BY2NJRxeCLI+D7VWh9AFaZSDG9iqzd9/npfW4be3aw9OtHdYjd9dddxEKmVvofvWrX/HNb36TCRMmkJ2dzcKFCzt0gNKhK8p2p9sj7NvN+6bzhvDg28XcOmUo1aHYUdsNVRtK4LGrjO6XTSS1NNS05PPAkmKuHtMvvcNpb/WRBFnu1uvPuGyamWybSuRtmty1aQrVqSOiykCUt76qYM6kQYzql83uQITPd9anv19TVs/IogwK/E5yvA6iCZ0bzxmEAOpCCTJctkNKyq0KREkkdGyKQr8cD267tl+101N6Z6Kkdk0FokkUhwW74iBuCAKRJHargsdmQRVm08ooChZVIxqKylwaqVvyOazEdQOHqhI3jHTRPVcPjR5ee7r/WRMFs8RBKJ4kFDs2koUFkND1A34u9MpykdHGmlvS/g4rqJk6dWr6+4EDB7Jx40Zqa2vJzMyUHbuPERpmk0doHtg8+LYZQBjK139MO7Kb997bqf1OKx6HhV6ZLjPZd/0ezuyXld6lUBc2dylMGJSDpoKjhSlXt+3rDtctsWngtGlYUwGR06oSSZi772pDcTTF3O6c47XTt4ebh5du5icTB6aDl0gySZ7XQY7XQTCuE47peJ0WVEUhljDIdFkZVuA75MchJ/V4VgWiFPjN1gjaXkUSa0MxFKCyMUqO10l5vdmAVNg0IgmdaFLHZrWmgj8LugGxZBKPzYKiyqlpqXvq4bFRGYyhqAqV9VE+2V7DD8b3R0WhJnTgdgkfbath8rC8zh5+ukt3MJIgw2klmjDr1AgBLpuF4oogo/plyYOWdjis5acmW7Zs4a233iISiZCVldVRY5I6gNtpRSjw+c56wvEkZbVmLsZZg3LI9ZlTnE27oTpqGaqsJsSehoi5TJJqKxBPGuysCeG0mP2UwvH9j5YUIM/rINDC7ieHVWPhp6Vmi4V9L7Oo9PA4sKsKDsBr0/jzsm14rBY8Vo18r4Msj521pfWAuSx0/cSBhBM6ewIx4rqBy6qxJxjlN/9Zz3+/3E0gmmBbVYjqxjhWTcVoZ5PMHJ8DFYVgLIHTZj7ekYSeri+T5XagCJFKXDZ3PIVjZq2NYCRBIJokHDdzggRmzlBQdt2Wuim/y4bPbiFpCBauKuWWyYPx2C3EdIOcFpZ0tlWFaIyZycJOq9bpS7fVjXE01Wzt8PnOBlTVnGkOx3UMA4b38iNr77XPYQU1NTU1nHvuuQwePJgLL7yQiooKAKZPn84tt9zSoQOUDo/fZcOuqfTL8ey3W6hp6aNpN1QwcvjdvPcEomyoCLCrJoRqGOR6HQgBRqoPmFVVCEYjqKlk3+dXlFDe8HWCssOqMaIok1A8sd/up4ZwnIRucM3Yfvu1WCj0OzijbxaldRFsmFO6duCHZw3gqWVbAbAoCg5V5bS+WcSTgt3BKLGkQQ+PHU0RJHSDbVVh4MD5Ok57+9e2HVaNnn4nFlVFU81t3vk+B7Uh83GobIym85yC0QQ+p/k7m3ZlBffKE5Idt6XuLi/DSSSuc/2k/iipQx2RSuBvLVnYoiidnlcTiCZAmEX29FTNrZ11EUKxJBsqGrBa2jXPIHGYQc3NN9+M1WqltLQUl+vrIm5XXHEFixcv7rDBSe3TK8tFT785U7D30odI/ff1bigrwZh+yIFNaU2IvyzbhsemmeuYillwbm8G4LM7zR09qnLA4OHtDfvXkqgMxkjoBnleO2cNygGgrDaCoRs4rRqNcd2sAcPXrT0tmIFNY8JgZyBKIK6nt0n38NjxO63EEzpOu7lt+28HmAVSgAK/g9wOWJbL8TlAQEMkjtOmpRO4m5pqZ7jt/OOznThtZo0amwrFFQEUBJWBWLPeT16nFa9DrrdL3Vs4ruO3WkkCT7y/BYumoAuBzapSuk+y8HnD8sj12UkKo9O3SrttFnbURNLF9/Y94FTg4HVspFYdVlCzZMkS7rvvPnr16tXs/EGDBrFjx44OGZjUMYqy3fgcFtw2Lb30EYw23w1ltZgVbZvya9piTyDKiyt2cO3oPlgw34c6UNEQIZkuNCeoaIigAwnDIPcAJcCbaknsu/upPpLAELCmtC59BOa0ahRlu/hoWw2BSMIMjOrM2ZYkZhAVjusEo2bF3aYieBhR7KlCXYFoEpdVY9HqMuZMHsJD+8wC5fscjB/Yg94dmEDtc1nJ8zr2m63ZVRvhwbc2MfPsgcR1A69NozqUYFS/bGwWlUWry3DZzN1bCgKPTZPbPaVuz+80A5o/Lt3MzEmDWL+rAYuqHKBRpDk7XVoTwWXXqOjEsghWTeGVT0vRDxC4aBy8jo3UusMKakKhULMZmia1tbXY7fZ2D0rqWD6nFa/Dgs9hSVfSbdoNNXfKUN5evzudNNzW/Jq6UJzpZ/ZBB3RhBjRJ0fLugqQwaAgnCceTrU4Pa/u8Gl02jfeKK+mZ6SQQTbCrLsyAHDdldRHyfA68DitryurZWhOmXo+1mPWuABYjTER10DPbTU0oTiCaRBcGc6cM4eF3ivnOaUXk+sxkXp/Dgtdh+bqpUgfxu2w4rBpf7mrAYdVI6Aa7U7MwN547CI/NzAOyG4J8n4OdtWH+761ibr9gGFbMFgneVGdvl1UGNVL3luez0xjX+dHEAVQ3RhhZlEF1KEKu19niVukMd6pshFXj423VnZZbUxOKc9vUoTy0ZBOh2Ne5cSoKuR4H1aEYqkyqaZfDCmomTJjAX//61/RpRVEwDIMFCxZw9tlnd9jgpI7hd9nMjPtYIl1JN9dn5+qxfSmvi7C6pA6rRTHzN1LBw8EEoklimLkzBuYMiQC27f2BEjQ/UATgsmu8vaHygLUk9g1owKwk3JRcvKsuwuj+WQSjSRpSTSWtFoUN5Q0U+J3UhwzChkAxzNkMs9VAgmBcJ6a60rMugYj5GJTWRKgLxbh6bN90QONxaARjCfYEotg7IJdmXwUZTqackGfe94RhBppOCx6bhk1TsKsK1UmDikCULK+deRcMw44ZmKkKNMbNXR85ndRpXZKOFX6XjUAkgYqCx2klKQSZTjsaMLpfNvk+R3qmJtfn+LpshKIwKM971CuqN/HYLeysDXPbBUPIdtsJxXTcdg1dCFbvqCXDbUd08AFVd3NYn9wLFizg3HPP5dNPPyUej3Pbbbfx1VdfUVtby/Llyzt6jFIH8Dmt6AJ21UdoiCQIx1XWlNWzobyBeReewOdldfhdNgoznFQ1xvHYLa1uK/Q5LDTGdXw2jahhYFVUahtj9N9rS6XXYcFlM8/P9jhYV1bPyT0z9rutpt1P1aEYfXqY55XVhNKVhP+5Zic/mTiQcNwgEE1iTyXTvb1+N/MuHMa9b27g5KIMzhuWi8tmIZJafvI5rGS6bent6nsCUbxOK+X1ERatLuOm84awuuTrTrnhuNk1fNzAHh2SS9MSv6v1Wjc5e32/JxClLjWz5HNYyHS7OmzrvSQd73xOK5G4jsdhoSEcoYfTSVwIhCL4fGc9uXuVjWja9ZkUBtG4QWU0hsduoedRbuzrsmk88skObp4yhGgy2Wz7eVG2C4uiEEkmj+qYuprDmqnx+Xxs2LCB8ePHc8kllxAKhbj00ktZs2YNVqtMYjwW+V02HBYVTVUoynLislmYemIeM87qT10oxvCiDBatLsNpVYkm9IMeyWS6zSMlHagOxjAMQY7HTm4qb0RVzMTgXK+DHI8dm6q0uvuptCacXpbaE4hSWmdWCrVpMOvsQXycyqHxODTWlNWzJxDl05I6yuuizDirP+cMzaUhoqcqKMfp5XcytMDXLAioC8WPei5Ne+T5HAwt8DGqX9Z+90WSujufw0I4rhOO62S6nCQUqAnH2pRX49BUdtSEj2qrGICaUIzbzh/Gg0uK91t+KvQ7+cPSzdg0ubzcHoc1U9OvXz8qKiq48847m51fU1NDr1690HVZR+NYlJ/hJKkbhBI6FtVI74baWRvhmeVmfk04nsRl+7o31IH+kOb5HNSGzOZytaE4vXxOdBSqGyP08DgAK4FUhV+PTSOi6xT6namdCI707qfSmhC5PjsvrdrBrVOGAmbw0RBJ4HdayHI70jk0TptGZSDGhvIGTuudyYwJ/Xl62TZOKPSnd1QJYaVPtovCFo7AApEENovC3ClDeGDJ0cmlkSTpyOiZ6aIxlqRhr1IQ4ahB72wXH22t3m8G9vR+WfxleTG3Th2KLcPB5j2N1IbixJMGRVlHZ8bGZtEwhMFPpwxtVll9dyDKY++VHbCyutR2hxXUiANkZzc2NuJwyKPJY5nXaWV3MIouBAYqVcE42V4bV4/tS10oxvbqEEMLfLjsZm+o1mYHvA4LDeEEwwv9ACQNg2y3nUjCbCrZpDGeTE2xGm1qk9C0q+mTkhrG9M9ptg3z1dVl3Hb+MBYsNpecbpo8GIBIXKdXppV8n6PF5Z2mpafSmghuu8rVY/s2m/oNxhKE40n6HCOzNJIkHVy+z4EhzM8MgAyPNZ1Xc8DPGUVJH1QFIgnWltYzfmD2UWkX47RqrC2t45TeGQdcIosm5aRAexxSUDN37lzATAz+xS9+0WwHlK7rrFy5khEjRnToAKWO5XfZKPA5+WBzNbk+e/pIZk8gyoAcD32y3WysCHBanyxqDtIbqlemi4r6Wpw2DU1VqA/H6OF2EIkn6OExm1c2zda47G1vk+B1Wlm7q47zTyigoiGazqF5r7iSq8f05aF3irlydJ9msyw5XjvZ7gPnqzQtPf3t09JOyaWRJKnj+V02GmNf56DUhxN4bZZW82oMIQhGEwzq4SaBIBLXqQklUAjR6wgHNgndoFeWK71E1rylg4VYIommygJ87XFIj96aNWtYs2YNQgi++OKL9Ok1a9awceNGTjnlFJ599tkjNFSpo/TMcjF+YDbZbjtZbhs5Xjsn9fSzI1V8r0+2G/bqDbWzld1Q/lSyXjiuk+txogtBjttBKJ5sVkPK0YY2CQ0RswO1x6oxZVgBwWgyvW17TyDKurJ6ogmDCXsV4gvHk3y+sx67praagBuIJNLbuFvKpRk3sAeKXHqSpONOz0xXun6Tz2H2bWstryaJ+dmmqgp2FHpmOYjrZvuR8iNcw0YAmS4bJdVhXDYLQoCigK6bhfkee3cLGbLvU7so4kBrSa247rrrePjhh/H5Dr3RX2cKBAL4/X4aGhqOu7F3tKpAlJpQjGhCEE3q6YJuGysC9Ml2oyiCPJ/ZaNHnsNDDa29xKaohHGfTnkaEEOT5HcT0JDZV40/LtvHDCf2JJAwCkQS5Xju7A9H9cmD8TitZLhsCg1DMPO20qpTWRVAVhR5eG797cwP/78y+OKzqfj+f4TRzaFrbxbAnEKU2FGdPQxS3XUUXNDtCCsWSWFWFggwXkbhOIGrOLvVoZeZHkqRjS3lNCAsQNgQ68Mm2mmb5e5WBKKP6Z7OutI7T+2bhTP1cdSyKxWKjLhTH6zi8BrZttaMmxENvFzP73MGUN0RpSC21N+1E/cVFJ8ol8ANo69/vwwpqjlcyqGmutCbE8i3VLb7xFcCiQEPMzIfJcFnx2S30bCGhrnh3IJ1f67FpPPnBVn40YQCRZAK31Uo8dWF1Y4wtlY3k7fX7mpa9Vmw3u+iGY+YWze3VIYqynCzbXMWUE/LT27bPHpILmDk0fpeVTJftoLuCNlQEcFk17lu8Yb+lJ7tFJRJPMrJXBoF4EoFCMLVkBpDltJKX4Wz19iVJOjbsrAuTTBrUReLEkgK3XWt28KIpivne13U8moYQqc85XUfXIRhNUJjhpNcR2uq9qyZERDcOuFHBChTIoKZFbf37fdws3l188cX07t0bh8NBQUEB06ZNo7y8vLOHdVzzO62MH9iDwgwnPTxmjZoxA7KpC0WxKApryupTvaE0ApEEH2yuarEwX77PgTvVVboxrvOjCf1BCBwWK7saIqzYVkNpTZg8r6P1NglWDW+qgaMZYMVYvc+27VBMR1FAIPDYLG3a5hyMJBBCtLj01Dvbwem9MkgIwW/+s4ELH17GFU+t4IKHl3HPf9YTSRqd3tlXkqS2CUaTxAyDLJed3Q0RNEXFkup7l+t1UOBz8KcPtuLUNBJATAjigEPT0kU7G8KJI/aeTxoCm6q0WPQTQfoAUDp8x01Qc/bZZ/O3v/2N4uJiFi1axNatW7nssss6e1jHNb/Lhi1VytfjMLdghxMGbruVqsYoJ/T0s2h1GZWBGE6bRq7PwY6a8H5veL/LhlNT8TrN2xCKglAVVm6vwRDwzoY9fFpaB0K03iYBcNkseJ1mHk3TTqfnPt7Oh1tq0pWKA5EkPf1Oeu01a7QnEKV4d4CNFQE2VARYvaOWrVWNNITj9PJacasKbk3lrguGMTjXg92q0i/DgUOzkADufO1Llm+paXa/PtxSw12vfZHeWSFJ0rEtEEng0DTWV5hlH4QQJA2BgWB7dYjf/ncD0ycMwDAE4bhOLGnQGNcJxXUE5kxzIJo8IhWH9wSiKKpCVWMUv9OKlq7npeJ3mp+5itzO3W7HTVBz8803c+aZZ9KnTx/Gjh3LHXfcwYoVK0gk5B+c9sjLcFLod6ApoCoKwhBYNZVgVOfBJWbTy1dXlwEQSxrURxItvuFzMpz4nVZ8Tmu6INbQAh9PL9vGlaP7sL68gahhoGktd9Ht4bUhVNhZF8Fl1dhQ3mD2p0rtdJp6Yh4um4U+WS56ZzrTO7Iq68KU1oRYsbUah0VlfXkDNotCjtssmR4PJ7CqGnEBSQFxIXjyg624VPNIrTGu0xjX9wtomny4pYbGuN6pTfAkSWobn9OKEILB+T4qgxFUFfwuK+GYTkGGkxvPHUzc0FEUs4lvMJL6iiYIxXUa42aBz4ZIkp21B28XcyjqQnEUARluO2tL66moj1ATilNRH2FtaT0ZbjuKnKhpt+MmqNlbbW0tL774ImPHjm21gnEsFiMQCDT7kvbnT+0AyvaYSbFNtWu+c1oRD75t1nZ4r7gSu0VN1XZItrgMVZjhxJtahmqa3Tih0M9LK3dw5eg+OCzafss/Tb1ZHlxSTCxhBk1JYTDvwmG8vHIHA3K9gLnTyRACt92CkZqi3VUTIm4I9gQijOydQVUwyojeGQDsCUawI0goEMOcZm5MJLlv8UZ+fNYA4kIQiCYJ7DXWAwlGE0QSsnaEJB3rvA4LFlUhaejoQsGqqQhDoKQO2MxcQRVDmDugvM7UV6pX3KurdlIZiOG2aZTWhtvUB6+tAtEkCWGgQIs7sxRkh+6OcFwFNbfffjtut5vs7GxKS0t5/fXXW73+vffei9/vT38VFRUdpZEef/wuG3ZN5fOd9YTjScpqzZmJCYNyiCbMnJc9gShryurNisPRlvuT9Mp2422asYnpjCzKSAc2qoC5U4bwzPLtXPTocr7/9AouenQ5zyzfztwpQwlEkqnEXZ26UIwZZ/VPz9AUZTnRVKgKRlEUhZ11YWKGIKYLdAGxpCApoDIYY+W2WgSQVFUSYDa1TBoIFC47rYjG1OlANIkvNdbWeB1WGdRI0nGgV6YLFXBZLPgcFmIJg1Bcx23TsFtVAtEEgUgci6rgs2nYLSoem4bTquJ1WLl2XD9eXV2GzapSH0lQ1RinvIMCG5/DQmlNhJrGWIuXH+h86dB0alBzxx13oChKq18bN25MX//WW29lzZo1LFmyBE3TuPrqqw9Y3Rhg3rx5NDQ0pL/KysqOxt06bpn1a3rgPEDOS4HfyfryBpxWs5v3gWS5bbhsGg6rll5iOqHQjy4EqgKzzhnIv24cx8szzuRfN45j1jkDsShms7c1ZfWUVIfI9znp6XWQ6bCS77PjtVno5XfSw2NHCGEmBCYNogkdt91CPGngtltw283k4Sy3ncbUMljTbEwwkiDXZ0+f9jjM5ECPTWP8wOwW78v4gdl4bRrhmAxqJOl4UJjtxgF4bBacNg23TSMc14knBeX1EbJSS9MWwK4q2IA/L9uGy6rRGNf5wbh+xBI6dovZBy8QTVKaquHVHm6bWfzT77KzvSqUzhGsDMTYXhUix+sgKlsMtVunbumuqqqipqblXIYm/fv3x2bbv1bIzp07KSoq4qOPPmLMmDFt+n1yS3frdtWFKasN0zPDSWMqGHCm6te8V1zJurJ6ZkwYQI7PRiIpWq3nUFETIgmU1UWoT+1mGpjjoTIYabFOTJ7XgQCeeH8LMycNoj4cIcPlZHcggkWFHh4HuwNRVAXyfE4qUk0xFUVBNwSaav4LUBeO0yfL7AujYFYoBrPwVUM4gd9lRQHK6yMM6OHGoSjEgDtf+4IP98qtGT8wm3u+PZzGUBiLzc6QfPmakaTjRVVqNjcY1wlGE3gdZh86O2bBT4H5v0eXbeWacf2xKFDZGCPHY2dVSS2ldRGmnJBHLGGwpTLIxCG5FLajvMMXO+vwOmwsWLyhxe3cj723mesnDmy1Mnp31ta/34fV+6mj5OTkkJOTc1g/axhmZdpYTE7ZdYSGcJyqYJzacIKiDCc2i8q2qsZ0PZeTCv3keuzk+uysK61jdP+WZzaaFGS72VMToijTaQYTkQSheIIsj51Ptu3fosDvtOG2asw6exAfbqlm3MAeLN9SDcDI3hks32oGG/1z3ARTy0Zg9psC0BQVXZjfh+Mqobievo7HppEwBLGk+QGS1A08dguLVpcx74JhRA0DgeDebw+ncZ8PQM0w+OOyUn777eFH4mGXJOkIyUnVmtkTiGIYAq9NoyKw/0HVN04ppC5k7vD0OqxEkwY5XgeLv9rNlBPycKV2fjZEEu0Kalw2a5uaWe4ORGVQ0w7HRU7NypUreeyxx1i7di07duzg3Xff5fvf/z4DBgxo8yyN1LrdgSjR1JRrIJ7AqkC/HE+LZcZP75vVagXfJiFDsL3anPnxO63UBBNYFXW/JLlBeW6CkQSGMNe/83wOwql/83wOBEr6e7fdYn4YpNbDN+0OEorpNMYShGI6oViSykAUd2pZyWvTiBs6NkXBYzXX2Z/5cBtWBW47fxiPvbcZVVHQVJVQQqcxmsRts2DVFLZWhbhnySbu+sYJ8kNGko5TeT4HPoeFsK6T53MecOnnz8u24bGZS+ub95iz0hsrAtit5k7NYDTBnnZs9e7hsbG2rCHdl2rv3MWmvlQKZv8qWRvr8B0XFYW/+OIL5syZw7p16wiFQhQUFHD++edz11130bNnzzbfjlx+OrBV22uxW1WWrN/DztoQcycPJqbrGEIhEEnisms4rRo2VWlz07eGcJxb/r6OsQOzOG9oPpsqGxmS4yFuiGZHKi6rhYRh4LSq7G6IUROKk+22URMy39h7f5/psuFxaOQ7rMQE6EBNKEqGy05qQhkBJJIGipLEb3GQTJ1rCLCp5lLTQ28X8+NJ/XFbrYSTOg5VRVEVkqmxhWM6fqeVPJ9dBjSS1AWs3FZDX7+DOKSX171OK0nd4JkPtzFn8hAiiQSg0sOqUZuIUh8xq5frQlCYYTbpHdqONgqlNSEqA1GSqZ2cXy/B6+R67dhVhZpIArfNwoBcT0fd9S7huFh+aqvhw4fz7rvvdvYwujSXTUMXgvXlDVw5ug8PvLOJH4zvj0VTMIRAVRSshxDQgLmj6s4Lh7FiWw2RZJLePZxoCtg0BRQzVycc13FYDbxWjfrUslJj7Ot/wcyJafre49CoDMTId1ixA0kFcj0OkoZAU1SaShbbbCpCWDCEwK4qJFAQCtTFdSLxBDedN4RwXKciEMXnsKJaFDCEXM+WpC7K57QSNczPMhB4nVaCqcDmRxMHoAJPvb+N2ecOJqpAls2BqpktDc4alMPgXA8V7SzK57Rq5PscRJIG8aSBpipoioqq6FhVhapQBFW1tLoRQ2rdcbH8JB15TpvGxooAMyb056WVO+iV5aYqGKOkOkQylYB7OJN6MV3nlKJM7KqGQ9GIC8GuhgifltQiEOR4rNg1jWCqqqfHplEZiOJK/bsnEEVBpL8PxZIsWl1GLJVLo2Nu2a5sjNGY2nbtAGyAE1BUhQgQTOrp+5E0zGDKaVVRgIRhsKshis2qyYBGkroov9OKAGrDETw2S7OWLQld8OA7xcyZPIS4YVYZjgIPLDHrdI0d0IPGuJlr1x45PgcI0FQFVVVACBQFenjs6IYgoSu8V1yJ235czDcck2RQIwHmskyfbBeqApOH5aW7YNstKqU1Ydw2japQ/JDXem2aRkVDBFVVaEwkWbm9FoA+2S5iiSSaqvLhlmoC0SRum0bCMBg7IJv6UISxA3owIMdNOJZg7IBsBuS40RSz1s1v3yqmOhJGg3TPlmDU7D0VA5KGTkwxJ240wGXRUFUFRTE/3OwWM5lYURQcFo1h+V7ZuFKSurDCDCcxwyDD5WRVSS0WTTE/NyIJLKrKzecN4fGlm3FZvu5jd+vUoWS6zQDoqfe34bZpB/09B6MLc7emEOZSuRDmeZ+V1tEY0/liZ0O6fY106GQ4KAFmdJvvc/DJ9lpO6ukHUktDFo3BuR6ShoHDqlHeEKUxmmyxW3dLbKpCvs9BY1xHoDC0wMeXuxoAc1dTIJo0E4BTxbGe+mAbMycOxG6zogpBT7+ThCEQgvT3ALefP4xwQmdXMEqex44n9WHTNG3rtWnYACU13StJkuS2aHxR3sAZfbPMiuKpvL6KhgiLUr3mNMwl72A0gXBYSeqCJ5cWM/Ocwc1qeB0uRVHYE4jgsVtJGoKSVNuYbTVhNn6xm599Y5hZlgLZrftwHBeJwh1FJgofWEM4Tm0oTjRpBh9Na80KAodFY01pHacUZbI7EKW0JsT4gT3S/ZcOdrv1kQS7U3VlnDaNqqC5Db8gw0lDOEFdOM7gPA+1oRiaovL31WVMn9CfpC7S4/DYNDQgZOjUNZrTwD6HpU27sCRJkgAq6sIkdEFVYwSX3brPZx14rBqO1LpUlK8Tiv2pz6BDySk8kIZwnOI9QUqqQ+mk46YDSIdV5d3iPZwzJK9dCcldUZdKFJaOPL/LRkM4QUMkiduuYQjQDYNQLEmjkqRnpguhCBoiCXJ9DsrqzK2IBwts/C4bwUjCbDQHBMIJYkkzHyaYquobjqvsrI3gtqtkuK2MG9gDXRfm9mq7BbvFzH2xAhoqhT4HGlAgAxpJkg5BQaaL3TUh8rzO9C5MVVHQFMwDuFRAExJmMc7lLRTj7NPOwCYUS5LrsbO1spGqYCy9zL+tqpECv5NPS+o4d2heu35HdyYX7qQ0BchwWtB1UMwcNlw2C9urzRLh0bie7q5dH0lQE0qwsw19UbxOK16bZn5oWLV0Y0yv00plIEZlIMrCVPnwdaX1DC3wYQgwhNmIzqoqqJiNKQFUVaGgA46YJEnqfvKz3VjU1OeKoiBS5R5cVgtRzBmafQMagA+31HDnP79o02fegTSE41QG44QTSU7s6cfRQkuaK0f3weg+CygdTgY1UprPZSUQTbK+ooFQLMnOughVwVh619D68gBryurTQUk0qae3WrfG77JhVxS8NgvZbjOQadrVtGh1Gaf1zeLqMX158O1i/C4b0YROQySBx27Ba9ewAFZhljvvn+OhUM7QSJLUDvmZLoqy3RT6HRSmcu7KG6I0xnUa4/p+AU2TD7fUEDxAM9+2qG6ME03oJA146J1NfLytJn2guHfzX5dVLqIcLvnISWl+l42iTBdbq1pu3tZUOrzQ76C8IcqUE/IIRtr2Bs/JclFZF8YwBOMGZrM7ECUcS3Db+UNZsHgjl5/em1umDCGWMAjHdbLcVoQh2BOM4nFY8RykiaYkSdKh8rtsxKNJtFT18V0NB69D057PoUA0gcuu8V5xJTMm9Oex97bw2Ltb0pePG5jNjecMIsPVvq3j3ZkMaqRmCjKcXHhSPrsDUerDZkPLHK+9WUPLaELnnQ17zL4o9rbvBsjNdNEQjiMiCXI9dgwAAfMuGEZjXKc2FMfrsJLrtfOHpZvJ9Tn5xvACgpEkQtDuGhGSJEn7yslysasuTHVjPN0vrjXt+RzyOayE4knWldVzcs8MvjG8wOwKnsqrqQxEKfA5ZL2sdpDLT9J+/C4bQ/J99O3hxqqpROI6Zw/J5abJg/mkpIbnV5Sk+6K4DnGLo99loyDbjVtVcKoKMd2gvCFKQje3jC9Zv5tf/vsrppxYwIbyBjw2DZfdnKXxdECNCEmSpH31zHTRL9uFJ9UzbvzAlhv2jh+Yjddx+HMBPTw2incHmTGhP8+vKKF8r5khh1VjRFEmVk1p5Rakg5FBjXRAeT4HPruFbVUhqoIxdtZFOKnQz+RheagK9O3hJst9eEcUOdluLECWVaPQ7yAYTaZv/4RCPy+v3MEvLjoRhxHBZTWL69lV+WaXJOnI8LtsFGW7cQC/+dbw/QKbpt1PvdqR0+d32Rg/sAeaqrRc5NSuyZzBdpJ1aqSD2lUXpiqV4OZKzZYU7w4yYWAP8ttRhbe8LowwBDa+rgkRjJo1aLw2Dbsh2BGKkec1E/naUhdHkiSpvarqwkQN0fwzyWFpV0Czt6a6YOFU81yv04LH3nG33xXJOjVSh+mZ6cJjt1DdGE+/waeckNfudd/CTBc7a0JEhSApzC3kTV8R3eCTnQ2c0ScTDXMbtyRJ0tGQc4SDC79LNs49UmRQI7XJkXoT9sp2U1EXRjEEwqoisBCKJfGpFs7sk4luCISqkC+PYCRJkqSDkEGN1On2rgy8sy6Mqig0RBIYAryyFYIkSZLURjKokY4pck1ZkiRJOlxy95MkSZIkSV2CDGokSZIkSeoSZFAjSZIkSVKXIIMaSZIkSZK6BBnUSJIkSZLUJcigRpIkSZKkLkEGNZIkSZIkdQkyqJEkSZIkqUuQQY0kSZIkSV2CDGokSZIkSeoSulWbBCEEYLYwlyRJkiTp+ND0d7vp7/iBdKugJhgMAlBUVNTJI5EkSZIk6VAFg0H8fv8BL1fEwcKeLsQwDMrLy/F6vSiK0tnD6VCBQICioiLKysrw+XydPZxuSz4PnU8+B8cG+Tx0vq70HAghCAaDFBYWoqoHzpzpVjM1qqrSq1evzh7GEeXz+Y77F29XIJ+Hziefg2ODfB46X1d5DlqboWkiE4UlSZIkSeoSZFAjSZIkSVKXIIOaLsJutzN//nzsdntnD6Vbk89D55PPwbFBPg+drzs+B90qUViSJEmSpK5LztRIkiRJktQlyKBGkiRJkqQuQQY1kiRJkiR1CTKo6eJisRgjRoxAURTWrl3b2cPpNkpKSpg+fTr9+vXD6XQyYMAA5s+fTzwe7+yhdXl/+MMf6Nu3Lw6Hg9GjR/PJJ5909pC6jXvvvZczzjgDr9dLbm4u3/rWtyguLu7sYXVrv/vd71AUhZtuuqmzh3JUyKCmi7vtttsoLCzs7GF0Oxs3bsQwDJ588km++uorHnzwQZ544gl+9rOfdfbQurSFCxcyd+5c5s+fz2effcYpp5zC1KlTqays7OyhdQvvv/8+M2fOZMWKFbz99tskEgmmTJlCKBTq7KF1S6tWreLJJ5/k5JNP7uyhHDVy91MX9t///pe5c+eyaNEiTjzxRNasWcOIESM6e1jd1v3338/jjz/Otm3bOnsoXdbo0aM544wzeOyxxwCzNUpRURE33ngjd9xxRyePrvupqqoiNzeX999/n7POOquzh9OtNDY2cuqpp/LHP/6R3/zmN4wYMYKHHnqos4d1xMmZmi5qz549zJgxg+effx6Xy9XZw5GAhoYGsrKyOnsYXVY8Hmf16tVMnjw5fZ6qqkyePJmPP/64E0fWfTU0NADI130nmDlzJt/4xjeavR+6g27V+6m7EEJw7bXXcv3113P66adTUlLS2UPq9rZs2cKjjz7K73//+84eSpdVXV2Nruvk5eU1Oz8vL4+NGzd20qi6L8MwuOmmmxg3bhwnnXRSZw+nW3nllVf47LPPWLVqVWcP5aiTMzXHkTvuuANFUVr92rhxI48++ijBYJB58+Z19pC7nLY+B3vbtWsX559/Pt/97neZMWNGJ41cko6umTNn8uWXX/LKK6909lC6lbKyMubMmcOLL76Iw+Ho7OEcdTKn5jhSVVVFTU1Nq9fp378/l19+Of/6179QFCV9vq7raJrGVVddxXPPPXekh9pltfU5sNlsAJSXlzNp0iTOPPNMnn32WVRVHkccKfF4HJfLxauvvsq3vvWt9PnXXHMN9fX1vP766503uG5m1qxZvP7663zwwQf069evs4fTrbz22mt8+9vfRtO09Hm6rqMoCqqqEovFml3W1cigpgsqLS0lEAikT5eXlzN16lReffVVRo8eTa9evTpxdN3Hrl27OPvssznttNN44YUXuvQHybFi9OjRjBo1ikcffRQwl0B69+7NrFmzZKLwUSCE4MYbb+Sf//wnS5cuZdCgQZ09pG4nGAyyY8eOZuddd911DB06lNtvv73LLwXKnJouqHfv3s1OezweAAYMGCADmqNk165dTJo0iT59+vD73/+eqqqq9GX5+fmdOLKube7cuVxzzTWcfvrpjBo1ioceeohQKMR1113X2UPrFmbOnMlLL73E66+/jtfrZffu3QD4/X6cTmcnj6578Hq9+wUubreb7OzsLh/QgAxqJOmIePvtt9myZQtbtmzZL5CUk6NHzhVXXEFVVRW/+MUv2L17NyNGjGDx4sX7JQ9LR8bjjz8OwKRJk5qd/8wzz3Dttdce/QFJ3Y5cfpIkSZIkqUuQWYuSJEmSJHUJMqiRJEmSJKlLkEGNJEmSJEldggxqJEmSJEnqEmRQI0mSJElSlyCDGkmSJEmSugQZ1EiSJEmS1CXIoEaSJEmSpC5BBjWSJB2Svn378tBDD3X2MA7btdde26zh5bHm7rvvZsSIEenThzNeRVF47bXXOnRc7dWWMR3rz4107JNBjXRMmTRpEjfddFNnD+OQlZSUoCgKa9eu7eyhpD311FNMmjQJn8+HoijU19d39pA63D/+8Q+mTJlCdnb2Mff4d5SHH36YZ599trOH0W4VFRVccMEFwIHfL13lvkqdRwY1ktRFhcNhzj//fH72s5919lA6XDweByAUCjF+/Hjuu+++Th7RkeP3+8nIyOjsYbRbfn4+dru91et0lfsqdR4Z1EjHjGuvvZb333+fhx9+GEVRUBSFkpISvvzySy644AI8Hg95eXlMmzaN6urq9M8tXryY8ePHk5GRQXZ2Nt/85jfZunVr+vKmo8K//e1vTJgwAafTyRlnnMGmTZtYtWoVp59+Oh6PhwsuuKBZN+2lS5cyatQo3G43GRkZjBs3jh07drQ49n79+gEwcuRIFEVp1tDvT3/6E8OGDcPhcDB06FD++Mc/NvvZ22+/ncGDB+Nyuejfvz8///nPSSQS6cubliP+8pe/0Lt3bzweDzfccAO6rrNgwQLy8/PJzc3lnnvuaXa7N910E3fccQdnnnlmm5+DSZMmMWvWLGbNmoXf76dHjx78/Oc/b7UJ5wMPPMDw4cNxu90UFRVxww030NjYCJhBh8/n49VXX232M6+99hput5tgMAhAWVkZl19+ORkZGWRlZXHJJZdQUlKSvn7TssQ999xDYWEhQ4YMAWDatGn84he/YPLkyW2+j01++ctfkpOTg8/n4/rrr08HSnDw11Q8HmfWrFkUFBTgcDjo06cP9957b/ry+vp6fvjDH6Zv/5xzzmHdunWHPMa973uTSZMmMXv2bG677TaysrLIz8/n7rvvbvU25s+fT0FBAZ9//nmLlze9xp588kmKiopwuVxcfvnlNDQ0pK9jGAa/+tWv6NWrF3a7Pd0stK2Pyd7LTwd6v+x7X2OxGLNnzyY3NxeHw8H48eNZtWpV+vKlS5eiKAr/+9//OP3003G5XIwdO5bi4uIDPhZ//etf8Xg8bN68OX3eDTfcwNChQwmHw60+jtJxQEjSMaK+vl6MGTNGzJgxQ1RUVIiKigpRXV0tcnJyxLx588SGDRvEZ599Js477zxx9tlnp3/u1VdfFYsWLRKbN28Wa9asERdddJEYPny40HVdCCHE9u3bBSCGDh0qFi9eLNavXy/OPPNMcdppp4lJkyaJDz/8UHz22Wdi4MCB4vrrrxdCCJFIJITf7xc//elPxZYtW8T69evFs88+K3bs2NHi2D/55BMBiHfeeUdUVFSImpoaIYQQL7zwgigoKBCLFi0S27ZtE4sWLRJZWVni2WefTf/sr3/9a7F8+XKxfft28cYbb4i8vDxx3333pS+fP3++8Hg84rLLLhNfffWVeOONN4TNZhNTp04VN954o9i4caP4y1/+IgCxYsWK/cb23nvvCUDU1dUd9DmYOHGi8Hg8Ys6cOWLjxo3ihRdeEC6XSzz11FPp6/Tp00c8+OCD6dMPPvigePfdd8X27dvF//73PzFkyBDxk5/8JH35jBkzxIUXXtjs91x88cXi6quvFkIIEY/HxbBhw8QPfvAD8fnnn4v169eLK6+8UgwZMkTEYjEhhBDXXHON8Hg8Ytq0aeLLL78UX375ZbPba3qO16xZc9D72HRbV1xxhfjyyy/Fv//9b5GTkyN+9rOfpa9zsNfU/fffL4qKisQHH3wgSkpKxLJly8RLL72U/vnJkyeLiy66SKxatUps2rRJ3HLLLSI7Ozv9umjN/PnzxSmnnNJsvJdcckn69MSJE4XP5xN333232LRpk3juueeEoihiyZIl6esA4p///KcwDEPMmjVL9O3bV2zevLnV3+l2u8U555wj1qxZI95//30xcOBAceWVV6av88ADDwifzydefvllsXHjRnHbbbcJq9UqNm3a1KbHpGlMQhz4/bLvfZ09e7YoLCwUb775pvjqq6/ENddcIzIzM9PXb3ptjx49WixdulR89dVXYsKECWLs2LGtPsbf/e53xRlnnCESiYT497//LaxWq/j0009b/Rnp+CCDGumYMnHiRDFnzpz06V//+tdiypQpza5TVlYmAFFcXNzibVRVVQlAfPHFF0KIr//g/elPf0pf5+WXXxaA+N///pc+79577xVDhgwRQghRU1MjALF06dI2jftAf1QHDBjQ7IO96T6NGTPmgLd1//33i9NOOy19ev78+cLlcolAIJA+b+rUqaJv377pP7JCCDFkyBBx77337nd7hxrUDBs2TBiGkT7v9ttvF8OGDUuf3jeo2dff//53kZ2dnT69cuVKoWmaKC8vF0IIsWfPHmGxWNKP7fPPPy+GDBnS7HfGYjHhdDrFW2+9JYQw/9jl5eWlg5x9HWpQk5WVJUKhUPq8xx9/XHg8nmaP5972fU3deOON4pxzzmk25ibLli0TPp9PRKPRZucPGDBAPPnkkwcdX1uCmvHjxzf7mTPOOEPcfvvt6dOA+Pvf/y6uvPJKMWzYMLFz586D/k5N05pd77///a9QVVVUVFQIIYQoLCwU99xzz36/94YbbhBCtP6YNI2pKag50PO1931tbGwUVqtVvPjii+nL4/G4KCwsFAsWLBBCfP3afuedd9LX+c9//iMAEYlEDnh/a2trRa9evcRPfvITkZeXt9/9ko5fcvlJOqatW7eO9957D4/Hk/4aOnQoQHo5YPPmzXz/+9+nf//++Hw++vbtC0BpaWmz2zr55JPT3+fl5QEwfPjwZudVVlYCkJWVxbXXXsvUqVO56KKLePjhh6moqDiksYdCIbZu3cr06dObjf83v/lNs6WMhQsXMm7cOPLz8/F4PNx11137jb1v3754vd5mYz3hhBNQVbXZeU3jb48zzzwTRVHSp8eMGcPmzZvRdb3F67/zzjuce+659OzZE6/Xy7Rp06ipqUlP5Y8aNYoTTzyR5557DoAXXniBPn36cNZZZwHmc7xlyxa8Xm/6McrKyiIajTZ7nIYPH47NZmv3/QM45ZRTcLlcze5jY2MjZWVlwMFfU9deey1r165lyJAhzJ49myVLlqRva926dTQ2NpKdnd3sed++fXuz+9Mee7+WAQoKCvZ77m+++WZWrlzJBx98QM+ePQ96m7179252vTFjxmAYBsXFxQQCAcrLyxk3blyznxk3bhwbNmwAWn9MDsfWrVtJJBLNfqfVamXUqFHp39lk78ejoKAAoNX3QmZmJn/+8595/PHHGTBgAHfccUe7xiodO2RQIx3TGhsbueiii1i7dm2zr82bN6f/KF500UXU1tby9NNPs3LlSlauXAnQLEcCzA/EJk1/tPc9zzCM9OlnnnmGjz/+mLFjx7Jw4UIGDx7MihUrDmnsAE8//XSzsX/55Zfp2/n444+56qqruPDCC/n3v//NmjVruPPOO1sde9NYWzpv7/EfDSUlJXzzm9/k5JNPZtGiRaxevZo//OEPQPPH/4c//GF6V8szzzzDddddl34OGhsbOe200/Z7jjdt2sSVV16Zvg23233U7tfBXlOnnnoq27dv59e//jWRSITLL7+cyy67LH1/CgoK9rs/xcXF3HrrrR0yvrY89+eddx67du3irbfe6pDfeTCtPSZHWkvv7YO9Fz744AM0TaOiooJQKHRExycdPZbOHoAk7c1mszWbETj11FNZtGgRffv2xWLZ/+VaU1NDcXExTz/9NBMmTADgww8/7LDxjBw5kpEjRzJv3jzGjBnDSy+91GLibdMMwt5jz8vLo7CwkG3btnHVVVe1ePsfffQRffr04c4770yfd6Bk5KOl6Q94kxUrVjBo0CA0TdvvuqtXr8YwDP7v//4vPWv0t7/9bb/r/b//9/+47bbbeOSRR1i/fj3XXHNN+rJTTz2VhQsXkpubi8/n6+B707J169YRiURwOp2AeR89Hg9FRUVtfk35fD6uuOIKrrjiCi677DLOP/98amtrOfXUU9m9ezcWiyU9w9MZLr74Yi666CKuvPJKNE3je9/7XqvXLy0tpby8nMLCQsB8TFRVZciQIfh8PgoLC1m+fDkTJ05M/8zy5csZNWpU+vSBHpOsrKxmv6ul98u+BgwYgM1mY/ny5fTp0weARCLBqlWr2l324aOPPuK+++7jX//6F7fffjuzZs1KzyRKxzc5UyMdU/r27cvKlSspKSmhurqamTNnUltby/e//31WrVrF1q1beeutt7juuuvQdZ3MzEyys7N56qmn2LJlC++++y5z585t9zi2b9/OvHnz+Pjjj9mxYwdLlixh8+bNDBs2DIBPPvmEoUOHsmvXLgByc3NxOp0sXryYPXv2pHeN/PKXv+Tee+/lkUceYdOmTXzxxRc888wzPPDAAwAMGjSI0tJSXnnlFbZu3cojjzzCP//5z3aPH2D37t2sXbuWLVu2APDFF1+wdu1aamtr09c599xzeeyxx5r9XGlpKXPnzqW4uJiXX36ZRx99lDlz5rT4OwYOHEgikeDRRx9l27ZtPP/88zzxxBP7XS8zM5NLL72UW2+9lSlTptCrV6/0ZVdddRU9evTgkksuYdmyZWzfvp2lS5cye/Zsdu7c2ep9rK2tZe3ataxfvx6A4uJi1q5dy+7du9PXufrqq5k3b16zn4vH40yfPp3169fz5ptvMn/+fGbNmoWqqm16TT3wwAO8/PLLbNy4kU2bNvH3v/+d/Px8MjIymDx5MmPGjOFb3/oWS5YsoaSkhI8++og777yTTz/9tNX709G+/e1v8/zzz3Pdddc124E2b948rr766mbXdTgcXHPNNaxbt45ly5Yxe/ZsLr/8cvLz8wG49dZbue+++1i4cCHFxcXccccdrF27Nv3aaO0x2deB3i97c7vd/OQnP+HWW29l8eLFrF+/nhkzZhAOh5k+fXqbH4N936vBYJBp06Yxe/ZsLrjgAl588UUWLly43w496fgkgxrpmPLTn/4UTdM44YQTyMnJIR6Ps3z5cnRdZ8qUKQwfPpybbrqJjIwMVFVFVVVeeeUVVq9ezUknncTNN9/M/fff3+5xuFwuNm7cyHe+8x0GDx7Mj370I2bOnMmPf/xjwKwBU1xcnN56bbFYeOSRR3jyyScpLCzkkksuAcxllz/96U8888wzDB8+nIkTJ/Lss8+mt7RefPHF3HzzzcyaNYsRI0bw0Ucf8fOf/7zd4wd44oknGDlyJDNmzADgrLPOYuTIkbzxxhvp62zdurXZ9ngwg4BIJMKoUaOYOXMmc+bM4Uc/+lGLv+OUU07hgQce4L777uOkk07ixRdfbLaNd2/Tp08nHo/zgx/8oNn5LpeLDz74gN69e3PppZcybNgwpk+fTjQaPejMzRtvvMHIkSP5xje+AcD3vvc9Ro4c2SywKi0t3S8f6txzz2XQoEGcddZZXHHFFVx88cXpbdFteU15vV4WLFjA6aefzhlnnEFJSQlvvvkmqqqiKApvvvkmZ511Ftdddx2DBw/me9/7Hjt27Ejnch1Nl112Gc899xzTpk3jH//4B2AWwts3b2vgwIFceumlXHjhhUyZMoWTTz65WfmB2bNnM3fuXG655RaGDx/O4sWLeeONNxg0aBDQ+mOyrwO9X/b1u9/9ju985ztMmzaNU089lS1btvDWW2+RmZnZ5vu/73t1zpw5uN1ufvvb3wJmrtZvf/tbfvzjH6cDH+n4pQjRSgEKSZK6lUmTJjFixIgj0gbh+eef5+abb6a8vLzDEn6ljnH33Xfz2muvdcmKzFL3InNqJEk6osLhMBUVFfzud7/jxz/+sQxoJEk6YuTykyRJR9SCBQsYOnQo+fn5++W2dEcnnnhis63ee3+9+OKLnT08STquyeUnSZKko2jHjh3N2mDsLS8vr1k9IkmSDo0MaiRJkiRJ6hLk8pMkSZIkSV2CDGokSZIkSeoSZFAjSZIkSVKXIIMaSZIkSZK6BBnUSJIkSZLUJcigRpIkSZKkLkEGNZIkSZIkdQkyqJEkSZIkqUv4/0s4Up6DziI/AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "teams = 1\n", + "player = 1\n", + "sns.scatterplot(data_feater, x=f\"teams.team{teams}.player{player}.base_link.position.x\", y=f\"teams.team{teams}.player{player}.base_link.position.y\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Questions\n", + "\n", + "- Why does game_control_data.kickoff_team 128 exist?" + ] + } + ], + "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.11.8" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/controllers/referee/data_collection/post_processing/merge_teamcomm.py b/controllers/referee/data_collection/post_processing/merge_teamcomm.py new file mode 100755 index 00000000..f5866de7 --- /dev/null +++ b/controllers/referee/data_collection/post_processing/merge_teamcomm.py @@ -0,0 +1,377 @@ +#!/usr/bin/python3 + +from typing import List, Optional, Tuple, Dict + +import os +import sys + +import pandas as pd +import robocup_extension_pb2 + +class TeamCommMessage: + def __init__(self, raw: str) -> None: + self.raw = raw + + # Extract time, sender IP, port and message + splits = self.raw[1:-2].split(", ") # Remove encapsulating brackets and newline, then split + self.time = float(splits[0]) + self.sender_IP = splits[1][1:-1] # Remove quotes + self.sender_port = int(splits[2]) + self.message = None + raw_message = splits[3] + # Interpret "b'\n\x07'" kind string as byte array + if raw_message.startswith("b'") and raw_message[-1] == "'": + self.message = eval(raw_message) + + +class Message: + def __init__(self, raw: str) -> None: + self.raw = raw + self.raw_bouncing_header = self.raw[:11] + self.raw_bouncing_body = self.raw[11:] + + self.blue_IPs: List[str] = [] + self.red_IPs: List[str] = [] + self.team_comm_message: Optional[TeamCommMessage] = None + + if self.defines_team(): + self.blue_IPs = self.get_blue_team_IPs() + self.red_IPs = self.get_red_team_IPs() + + if self.is_team_comm(): + self.team_comm_message = TeamCommMessage(self.raw_bouncing_body) + + def is_team_comm(self) -> bool: + return self.raw_bouncing_body[0] == "[" + + def defines_team(self) -> bool: + return self.raw_bouncing_body.startswith("Robots in team ") + + def get_blue_team_IPs(self) -> List[str]: + """ + Example raw body: "Robots in team blue are ['172.31.13.184', '172.31.15.77', '172.31.1.9', '172.31.8.39']" + We want to return the list of IPs + """ + # Check if the message is a team definition + if not self.defines_team() or not self.raw_bouncing_body[15:19] == "blue": + return [] + # Extract the list of IPs + raw_IPs = self.raw_bouncing_body[25:-2] # Remove the "Robots in team blue are " and the last "]\n" + raw_IPs = raw_IPs.split(", ") # Split the IPs + raw_IPs = [raw_IP[1:-1] for raw_IP in raw_IPs] # Remove the quotes + return raw_IPs + + def get_red_team_IPs(self) -> List[str]: + """ + Example raw body: "Robots in team red are ['172.31.13.184', '172.31.15.77', '172.31.1.9', '172.31.8.39']" + We want to return the list of IPs + """ + # Check if the message is a team definition + if not self.defines_team() or not self.raw_bouncing_body[15:18] == "red": + return [] + # Extract the list of IPs + raw_IPs = self.raw_bouncing_body[24:-2] # Remove the "Robots in team red are " and the last "]" + raw_IPs = raw_IPs.split(", ") # Split the IPs + raw_IPs = [raw_IP[1:-1] for raw_IP in raw_IPs] # Remove the quotes + return raw_IPs + + +def parse_bouncing_log(bouncing_log: List[str]) -> List[Message]: + messages = [] + for raw_message in bouncing_log: + try: + messages.append(Message(raw_message)) + except: + pass + return messages + +def get_team_proto_messages(messages: List[Message]) -> Tuple[List[robocup_extension_pb2.Message], List[robocup_extension_pb2.Message]]: + # Get the team IPs + blue_IPs = [] + red_IPs = [] + for message in messages: + if message.blue_IPs: + blue_IPs = message.blue_IPs + if message.red_IPs: + red_IPs = message.red_IPs + if blue_IPs and red_IPs: + break + + # Assign the messages to the teams + blue_messages = [] + red_messages = [] + + for message in messages: + if message.team_comm_message: + if message.team_comm_message.sender_IP in blue_IPs: + blue_messages.append(message) + elif message.team_comm_message.sender_IP in red_IPs: + red_messages.append(message) + + # Try to parse the messages + blue_proto: List[robocup_extension_pb2.Message] = [] + red_proto: List[robocup_extension_pb2.Message] = [] + + for message in blue_messages: + if message.team_comm_message.message: + try: + proto = robocup_extension_pb2.Message() + proto.ParseFromString(message.team_comm_message.message) + blue_proto.append(proto) + except Exception as e: + print(e) + + for message in red_messages: + if message.team_comm_message.message: + try: + proto = robocup_extension_pb2.Message() + proto.ParseFromString(message.team_comm_message.message) + red_proto.append(proto) + except Exception as e: + print(e) + + return blue_proto, red_proto + +def insert_new_columns_to_df(df: pd.DataFrame) -> pd.DataFrame: + # TODO: This adds a lot of new sparse columns + # Consider using a sparse dataframe instead + # An filter intelligently which columns are strictly necessary from the input data + + # Generate column names + columns = [] + + for team in [1, 2]: + for player_id in range(1, 4+1): + base_name = f'teams.team{team}.player{player_id}' + + # Skip if the player is not in the match + if f'{base_name}.id' not in df.columns: + continue + + base_name += '.team_comm' + + columns.append(f'{base_name}.self_localization.pose.position.x') + columns.append(f'{base_name}.self_localization.pose.position.y') + columns.append(f'{base_name}.self_localization.pose.position.z') + for i in range(3*3): + columns.append(f'{base_name}.self_localization.covariance.{i}') + + columns.append(f'{base_name}.walk_command.x') + columns.append(f'{base_name}.walk_command.y') + columns.append(f'{base_name}.walk_command.z') + + columns.append(f'{base_name}.target_pose.pose.position.x') + columns.append(f'{base_name}.target_pose.pose.position.y') + columns.append(f'{base_name}.target_pose.pose.position.z') + for i in range(3*3): + columns.append(f'{base_name}.target_pose.pose.covariance.{i}') + + columns.append(f'{base_name}.kick_target.x') + columns.append(f'{base_name}.kick_target.y') + + columns.append(f'{base_name}.ball.position.x') + columns.append(f'{base_name}.ball.position.y') + columns.append(f'{base_name}.ball.position.z') + columns.append(f'{base_name}.ball.velocity.x') + columns.append(f'{base_name}.ball.velocity.y') + columns.append(f'{base_name}.ball.velocity.z') + for i in range(3*3): + columns.append(f'{base_name}.ball.covariance.{i}') + + # Other players + for others_team in [1, 2, "_unknown"]: + others_player_ids = list(range(1, 4+1)) + if others_team == team: + others_player_ids.remove(player_id) + if others_team == "_unknown": + # There is no mapping, therefore we use placeholders + others_player_ids = list(range(1, 7+1)) + for others_player_id in others_player_ids: + others_base_name = f'{base_name}.others.team{others_team}.player{others_player_id}' + columns.append(f'{others_base_name}.pose.position.x') + columns.append(f'{others_base_name}.pose.position.y') + columns.append(f'{others_base_name}.pose.position.z') + columns.append(f'{others_base_name}.confidence') + for i in range(3*3): + columns.append(f'{others_base_name}.covariance.{i}') + + # Extensions + columns.append(f'{base_name}.time_to_ball') + columns.append(f'{base_name}.role') + columns.append(f'{base_name}.action') + + # New temporary dataframe to concat with the original one + new_df = pd.DataFrame(columns=columns) + return pd.concat([df, new_df], axis=1) + +def fill_df_with_data(df: pd.DataFrame, blue_proto: List[robocup_extension_pb2.Message], red_proto: List[robocup_extension_pb2.Message]): + def handle_team(df: pd.DataFrame, msgs, current_team: int, current_other_team: int) -> pd.DataFrame: + for msg in msgs: + row = {} # This is where we collect the data from this message + player_id = msg.current_pose.player_id + my_team_id = msg.current_pose.team + base_name = f'teams.team{current_team}.player{player_id}.team_comm' + + time = msg.timestamp.seconds + msg.timestamp.nanos * 1e-9 + + # Skip if msg time is greater than the last time in the dataframe + if time >= df['time'].iloc[-1]: + continue + + idx = df['time'][df['time'] > time].index[0] # Find the index of the first row with a time greater than the message time + + # Insert self localization + row[f'{base_name}.self_localization.pose.position.x'] = msg.current_pose.position.x + row[f'{base_name}.self_localization.pose.position.y'] = msg.current_pose.position.y + row[f'{base_name}.self_localization.pose.position.z'] = msg.current_pose.position.z + row[f'{base_name}.self_localization.pose.covariance.0'] = msg.current_pose.covariance.x.x + row[f'{base_name}.self_localization.pose.covariance.1'] = msg.current_pose.covariance.x.y + row[f'{base_name}.self_localization.pose.covariance.2'] = msg.current_pose.covariance.x.z + row[f'{base_name}.self_localization.pose.covariance.3'] = msg.current_pose.covariance.y.x + row[f'{base_name}.self_localization.pose.covariance.4'] = msg.current_pose.covariance.y.y + row[f'{base_name}.self_localization.pose.covariance.5'] = msg.current_pose.covariance.y.z + row[f'{base_name}.self_localization.pose.covariance.6'] = msg.current_pose.covariance.z.x + row[f'{base_name}.self_localization.pose.covariance.7'] = msg.current_pose.covariance.z.y + row[f'{base_name}.self_localization.pose.covariance.8'] = msg.current_pose.covariance.z.z + + # Insert walk command + row[f'{base_name}.walk_command.x'] = msg.walk_command.x + row[f'{base_name}.walk_command.y'] = msg.walk_command.y + row[f'{base_name}.walk_command.z'] = msg.walk_command.z + + # Insert target pose + row[f'{base_name}.target_pose.pose.position.x'] = msg.target_pose.position.x + row[f'{base_name}.target_pose.pose.position.y'] = msg.target_pose.position.y + row[f'{base_name}.target_pose.pose.position.z'] = msg.target_pose.position.z + row[f'{base_name}.target_pose.covariance.0'] = msg.target_pose.covariance.x.x + row[f'{base_name}.target_pose.covariance.1'] = msg.target_pose.covariance.x.y + row[f'{base_name}.target_pose.covariance.2'] = msg.target_pose.covariance.x.z + row[f'{base_name}.target_pose.covariance.3'] = msg.target_pose.covariance.y.x + row[f'{base_name}.target_pose.covariance.4'] = msg.target_pose.covariance.y.y + row[f'{base_name}.target_pose.covariance.5'] = msg.target_pose.covariance.y.z + row[f'{base_name}.target_pose.covariance.6'] = msg.target_pose.covariance.z.x + row[f'{base_name}.target_pose.covariance.7'] = msg.target_pose.covariance.z.y + row[f'{base_name}.target_pose.covariance.8'] = msg.target_pose.covariance.z.z + + # Insert kick target + row[f'{base_name}.kick_target.x'] = msg.kick_target.x + row[f'{base_name}.kick_target.y'] = msg.kick_target.y + + # Insert ball observation + row[f'{base_name}.ball.position.x'] = msg.ball.position.x + row[f'{base_name}.ball.position.y'] = msg.ball.position.y + row[f'{base_name}.ball.position.z'] = msg.ball.position.z + row[f'{base_name}.ball.velocity.x'] = msg.ball.velocity.x + row[f'{base_name}.ball.velocity.y'] = msg.ball.velocity.y + row[f'{base_name}.ball.velocity.z'] = msg.ball.velocity.z + row[f'{base_name}.ball.covariance.0'] = msg.ball.covariance.x.x + row[f'{base_name}.ball.covariance.1'] = msg.ball.covariance.x.y + row[f'{base_name}.ball.covariance.2'] = msg.ball.covariance.x.z + row[f'{base_name}.ball.covariance.3'] = msg.ball.covariance.y.x + row[f'{base_name}.ball.covariance.4'] = msg.ball.covariance.y.y + row[f'{base_name}.ball.covariance.5'] = msg.ball.covariance.y.z + row[f'{base_name}.ball.covariance.6'] = msg.ball.covariance.z.x + row[f'{base_name}.ball.covariance.7'] = msg.ball.covariance.z.y + row[f'{base_name}.ball.covariance.8'] = msg.ball.covariance.z.z + + # Insert other players + current_team_count = current_other_team_count = unknown_count = -1 + count = 0 + for i, other in enumerate(msg.others): + # Determine team (mine, opponent, or unknown) + if other.team == my_team_id: + others_team = current_team + current_team_count += 1 + count = current_team_count + elif other.team != 0: + others_team = current_other_team + current_other_team_count += 1 + count = current_other_team_count + else: + others_team = "_unknown" + unknown_count += 1 + count = unknown_count + # We ignore the player_id field because no team detects the player number + + others_base_name = f'{base_name}.others.team{others_team}.player{count}' + + # Insert pose + row[f'{others_base_name}.pose.position.x'] = other.position.x + row[f'{others_base_name}.pose.position.y'] = other.position.y + row[f'{others_base_name}.pose.position.z'] = other.position.z + + # Insert confidence + confidence = None + if len(msg.other_robot_confidence) > i: + confidence = msg.other_robot_confidence[i] + row[f'{others_base_name}.confidence'] = confidence + + # Insert covariance + row[f'{others_base_name}.covariance.0'] = other.covariance.x.x + row[f'{others_base_name}.covariance.1'] = other.covariance.x.y + row[f'{others_base_name}.covariance.2'] = other.covariance.x.z + row[f'{others_base_name}.covariance.3'] = other.covariance.y.x + row[f'{others_base_name}.covariance.4'] = other.covariance.y.y + row[f'{others_base_name}.covariance.5'] = other.covariance.y.z + row[f'{others_base_name}.covariance.6'] = other.covariance.z.x + row[f'{others_base_name}.covariance.7'] = other.covariance.z.y + row[f'{others_base_name}.covariance.8'] = other.covariance.z.z + + # Insert extensions + row[f'{base_name}.time_to_ball'] = msg.time_to_ball + row[f'{base_name}.role'] = msg.role + row[f'{base_name}.action'] = msg.action + + # Insert the column data from row into the dataframe at the index + for col, value in row.items(): + df.at[idx, col] = value + + return df + + # Blue is team1, red is team2 + # Insert blue data + df = handle_team(df, blue_proto, 1, 2) + df = handle_team(df, red_proto, 2, 1) + + return df + +if __name__ == "__main__": + match_dir = sys.argv[1] + + # Read the bouncing log file + with open(os.path.join(match_dir, "bouncing_log.txt"), "r") as f: + bouncing_log: List[str] = f.readlines() + + # Parse the bouncing log file + messages = parse_bouncing_log(bouncing_log) + + # Get the team proto messages + blue_proto, red_proto = get_team_proto_messages(messages) + print(len(red_proto)) + exit(0) + + # Load the match data collection + # Find files that match the pattern "referee_data_collection_*.feather" + feather_file = None + data_collection_dir = os.path.join(match_dir, "data_collection") + for file in os.listdir(data_collection_dir): + if file.startswith("referee_data_collection_") and file.endswith(".feather"): + feather_file = file + break + + if feather_file is None: + print("No referee data collection file found") + exit(1) + + # Load the data + referee_data_collection = pd.read_feather(os.path.join(data_collection_dir, feather_file)) + + # Insert new columns + referee_data_collection = insert_new_columns_to_df(referee_data_collection) + + # Fill the new columns with the proto messages + referee_data_collection = fill_df_with_data(referee_data_collection, blue_proto, red_proto) + + # Save the new dataframe as feather + feather_file = feather_file.replace(".feather", "_with_team_communication.feather") + #referee_data_collection.to_feather(os.path.join(data_collection_dir, feather_file)) diff --git a/controllers/referee/data_collection/post_processing/robocup.proto b/controllers/referee/data_collection/post_processing/robocup.proto new file mode 100644 index 00000000..5824ed62 --- /dev/null +++ b/controllers/referee/data_collection/post_processing/robocup.proto @@ -0,0 +1,109 @@ +syntax = "proto3"; + +package robocup.humanoid; + +import "google/protobuf/timestamp.proto"; + +/// A column vector of two floats +message fvec2 { + float x = 1; + float y = 2; +} + +/// A column vector of three floats +message fvec3 { + float x = 1; + float y = 2; + float z = 3; +} + +/// A matrix of three vectors +/// Specified as column vectors +message fmat3 { + fvec3 x = 1; + fvec3 y = 2; + fvec3 z = 3; +} + +/// The detected team of the robot +enum Team { + UNKNOWN_TEAM = 0; + BLUE = 1; + RED = 2; +} + +message Robot { + /// ID of the robot, 0 if not known + uint32 player_id = 1; + + /// The position of the robot on the field according to the following convention + /// x meters along the field with 0 at the centre of the field and positive towards opponent goals + /// y meters across the field with 0 at the centre of the field and positive to the left + /// θ orientation of the robot (anti-clockwise from the x axis from above the field) + fvec3 position = 2; + + /// The covariance measure of the robots [x, y, θ] values + /// If this is unavailable leave this unset + fmat3 covariance = 3; + + /// Robot team, if known + Team team = 4; +} + +message Ball { + /// The position of the ball on the field according to the following convention + /// x meters along the field with 0 at the centre of the field and positive towards opponent goals + /// y meters across the field with 0 at the centre of the field and positive to the left + /// z meters above the field with 0 at the surface of the field and positive up + fvec3 position = 1; + + /// The velocity of the ball + /// x m/s along the field with 0 at the centre of the field and positive towards opponent goals + /// y m/s across the field with 0 at the centre of the field and positive to the left + /// z m/s above the field with 0 at the surface of the field and positive up + /// Set to 0 if not available + fvec3 velocity = 2; + + /// The covariance measure of the balls [x, y, z] values + /// If this is unavailable leave this unset + fmat3 covariance = 3; +} + +/// The current playing state of the robot +enum State { + UNKNOWN_STATE = 0; + UNPENALISED = 1; + PENALISED = 2; +} + +message Message { + /// Timestamp of message creation + google.protobuf.Timestamp timestamp = 1; + + /// The robots current state + State state = 2; + + /// Position, orientation, and covariance of the player on the field + Robot current_pose = 3; + + /// The current walk speed of the robot in it's local [x, y, θ] coordinates + /// x and y in m/s and θ in rad/s + /// positive x being forwards, positive y being strafing to the left, and positive θ being anti-clockwise + fvec3 walk_command = 4; + + /// Position and orientation of the players target on the field specified + Robot target_pose = 5; + + /// Position that the robot is aiming to kick the ball to + /// If no kick is planned set to [0, 0] + /// Vector has origin on the ground between the robots feet + fvec2 kick_target = 6; + + /// Position, velocity, and covariance of the ball on the field + Ball ball = 7; + + /// Position, orientation, and covariance of detected robots on the field + repeated Robot others = 8; + + /// IDs 1-100 are reserved for official use +} diff --git a/controllers/referee/data_collection/post_processing/robocup_extension.proto b/controllers/referee/data_collection/post_processing/robocup_extension.proto new file mode 100644 index 00000000..57023ec2 --- /dev/null +++ b/controllers/referee/data_collection/post_processing/robocup_extension.proto @@ -0,0 +1,162 @@ +syntax = "proto3"; + +package robocup.humanoid; + +import "google/protobuf/timestamp.proto"; + +/// A column vector of two floats +message fvec2 { + float x = 1; + float y = 2; +} + +/// A column vector of three floats +message fvec3 { + float x = 1; + float y = 2; + float z = 3; +} + +/// A matrix of three vectors +/// Specified as column vectors +message fmat3 { + fvec3 x = 1; + fvec3 y = 2; + fvec3 z = 3; +} + +/// The detected team of the robot +enum Team { + UNKNOWN_TEAM = 0; + BLUE = 1; + RED = 2; +} + +message Robot { + /// ID of the robot, 0 if not known + uint32 player_id = 1; + + /// The position of the robot on the field according to the following convention + /// x meters along the field with 0 at the centre of the field and positive towards opponent goals + /// y meters across the field with 0 at the centre of the field and positive to the left + /// θ orientation of the robot (anti-clockwise from the x axis from above the field) + fvec3 position = 2; + + /// The covariance measure of the robots [x, y, θ] values + /// If this is unavailable leave this unset + fmat3 covariance = 3; + + /// Robot team, if known + Team team = 4; +} + +message Ball { + /// The position of the ball on the field according to the following convention + /// x meters along the field with 0 at the centre of the field and positive towards opponent goals + /// y meters across the field with 0 at the centre of the field and positive to the left + /// z meters above the field with 0 at the surface of the field and positive up + fvec3 position = 1; + + /// The velocity of the ball + /// x m/s along the field with 0 at the centre of the field and positive towards opponent goals + /// y m/s across the field with 0 at the centre of the field and positive to the left + /// z m/s above the field with 0 at the surface of the field and positive up + /// Set to 0 if not available + fvec3 velocity = 2; + + /// The covariance measure of the balls [x, y, z] values + /// If this is unavailable leave this unset + fmat3 covariance = 3; +} + +/// The current playing state of the robot +enum State { + UNKNOWN_STATE = 0; + UNPENALISED = 1; + PENALISED = 2; +} + +/// The role of the robot +enum Role { + ROLE_UNDEFINED = 0; + ROLE_IDLING=1; + ROLE_OTHER=2; + ROLE_STRIKER=3; + ROLE_SUPPORTER=4; + ROLE_DEFENDER=5; + ROLE_GOALIE=6; +} + +/// The current action of the robot +enum Action { + ACTION_UNDEFINED=0; + ACTION_POSITIONING=1; + ACTION_GOING_TO_BALL=2; + ACTION_TRYING_TO_SCORE=3; + ACTION_WAITING=4; + ACTION_KICKING=5; + ACTION_SEARCHING=6; + ACTION_LOCALIZING=7; +} + +/// The offensive strategy of the robot +enum OffensiveSide { + SIDE_UNDEFINED = 0; + SIDE_LEFT = 1; + SIDE_MIDDLE = 2; + SIDE_RIGHT = 3; +} + +message Message { + /// Timestamp of message creation + google.protobuf.Timestamp timestamp = 1; + + /// The robots current state + State state = 2; + + /// Position, orientation, and covariance of the player on the field + Robot current_pose = 3; + + /// The current walk speed of the robot in it's local [x, y, θ] coordinates + /// x and y in m/s and θ in rad/s + /// positive x being forwards, positive y being strafing to the left, and positive θ being anti-clockwise + fvec3 walk_command = 4; + + /// Position and orientation of the players target on the field specified + Robot target_pose = 5; + + /// Position that the robot is aiming to kick the ball to + /// If no kick is planned set to [0, 0] + /// Vector has origin on the ground between the robots feet + fvec2 kick_target = 6; + + /// Position, velocity, and covariance of the ball on the field + Ball ball = 7; + + /// Position, orientation, and covariance of detected robots on the field + repeated Robot others = 8; + + /// IDs 1-100 are reserved for official use + + /**************************** + * EXTENSIONS GO BELOW HERE * + ****************************/ + + /// Maximum walking speed of the robot + float max_walking_speed = 101; + + /// Time the robot needs to reach the ball; + float time_to_ball = 104; + + /// The role of the robot + Role role = 105; + + /// The current action of the robot + Action action = 106; + + /// The offensive strategy of the robot + OffensiveSide offensive_side = 107; + + /// Confidence values of the obstacles + repeated float other_robot_confidence = 108; +} diff --git a/controllers/referee/data_collection/post_processing/robocup_extension_pb2.py b/controllers/referee/data_collection/post_processing/robocup_extension_pb2.py new file mode 100644 index 00000000..d7b6b3ed --- /dev/null +++ b/controllers/referee/data_collection/post_processing/robocup_extension_pb2.py @@ -0,0 +1,46 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: robocup_extension.proto +"""Generated protocol buffer code.""" +from google.protobuf.internal import builder as _builder +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x17robocup_extension.proto\x12\x10robocup.humanoid\x1a\x1fgoogle/protobuf/timestamp.proto\"\x1d\n\x05\x66vec2\x12\t\n\x01x\x18\x01 \x01(\x02\x12\t\n\x01y\x18\x02 \x01(\x02\"(\n\x05\x66vec3\x12\t\n\x01x\x18\x01 \x01(\x02\x12\t\n\x01y\x18\x02 \x01(\x02\x12\t\n\x01z\x18\x03 \x01(\x02\"s\n\x05\x66mat3\x12\"\n\x01x\x18\x01 \x01(\x0b\x32\x17.robocup.humanoid.fvec3\x12\"\n\x01y\x18\x02 \x01(\x0b\x32\x17.robocup.humanoid.fvec3\x12\"\n\x01z\x18\x03 \x01(\x0b\x32\x17.robocup.humanoid.fvec3\"\x98\x01\n\x05Robot\x12\x11\n\tplayer_id\x18\x01 \x01(\r\x12)\n\x08position\x18\x02 \x01(\x0b\x32\x17.robocup.humanoid.fvec3\x12+\n\ncovariance\x18\x03 \x01(\x0b\x32\x17.robocup.humanoid.fmat3\x12$\n\x04team\x18\x04 \x01(\x0e\x32\x16.robocup.humanoid.Team\"\x89\x01\n\x04\x42\x61ll\x12)\n\x08position\x18\x01 \x01(\x0b\x32\x17.robocup.humanoid.fvec3\x12)\n\x08velocity\x18\x02 \x01(\x0b\x32\x17.robocup.humanoid.fvec3\x12+\n\ncovariance\x18\x03 \x01(\x0b\x32\x17.robocup.humanoid.fmat3\"\xc3\x04\n\x07Message\x12-\n\ttimestamp\x18\x01 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12&\n\x05state\x18\x02 \x01(\x0e\x32\x17.robocup.humanoid.State\x12-\n\x0c\x63urrent_pose\x18\x03 \x01(\x0b\x32\x17.robocup.humanoid.Robot\x12-\n\x0cwalk_command\x18\x04 \x01(\x0b\x32\x17.robocup.humanoid.fvec3\x12,\n\x0btarget_pose\x18\x05 \x01(\x0b\x32\x17.robocup.humanoid.Robot\x12,\n\x0bkick_target\x18\x06 \x01(\x0b\x32\x17.robocup.humanoid.fvec2\x12$\n\x04\x62\x61ll\x18\x07 \x01(\x0b\x32\x16.robocup.humanoid.Ball\x12\'\n\x06others\x18\x08 \x03(\x0b\x32\x17.robocup.humanoid.Robot\x12\x19\n\x11max_walking_speed\x18\x65 \x01(\x02\x12\x14\n\x0ctime_to_ball\x18h \x01(\x02\x12$\n\x04role\x18i \x01(\x0e\x32\x16.robocup.humanoid.Role\x12(\n\x06\x61\x63tion\x18j \x01(\x0e\x32\x18.robocup.humanoid.Action\x12\x37\n\x0eoffensive_side\x18k \x01(\x0e\x32\x1f.robocup.humanoid.OffensiveSide\x12\x1e\n\x16other_robot_confidence\x18l \x03(\x02*+\n\x04Team\x12\x10\n\x0cUNKNOWN_TEAM\x10\x00\x12\x08\n\x04\x42LUE\x10\x01\x12\x07\n\x03RED\x10\x02*:\n\x05State\x12\x11\n\rUNKNOWN_STATE\x10\x00\x12\x0f\n\x0bUNPENALISED\x10\x01\x12\r\n\tPENALISED\x10\x02*\x85\x01\n\x04Role\x12\x12\n\x0eROLE_UNDEFINED\x10\x00\x12\x0f\n\x0bROLE_IDLING\x10\x01\x12\x0e\n\nROLE_OTHER\x10\x02\x12\x10\n\x0cROLE_STRIKER\x10\x03\x12\x12\n\x0eROLE_SUPPORTER\x10\x04\x12\x11\n\rROLE_DEFENDER\x10\x05\x12\x0f\n\x0bROLE_GOALIE\x10\x06*\xc1\x01\n\x06\x41\x63tion\x12\x14\n\x10\x41\x43TION_UNDEFINED\x10\x00\x12\x16\n\x12\x41\x43TION_POSITIONING\x10\x01\x12\x18\n\x14\x41\x43TION_GOING_TO_BALL\x10\x02\x12\x1a\n\x16\x41\x43TION_TRYING_TO_SCORE\x10\x03\x12\x12\n\x0e\x41\x43TION_WAITING\x10\x04\x12\x12\n\x0e\x41\x43TION_KICKING\x10\x05\x12\x14\n\x10\x41\x43TION_SEARCHING\x10\x06\x12\x15\n\x11\x41\x43TION_LOCALIZING\x10\x07*S\n\rOffensiveSide\x12\x12\n\x0eSIDE_UNDEFINED\x10\x00\x12\r\n\tSIDE_LEFT\x10\x01\x12\x0f\n\x0bSIDE_MIDDLE\x10\x02\x12\x0e\n\nSIDE_RIGHT\x10\x03\x62\x06proto3') + +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals()) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'robocup_extension_pb2', globals()) +if _descriptor._USE_C_DESCRIPTORS == False: + + DESCRIPTOR._options = None + _TEAM._serialized_start=1145 + _TEAM._serialized_end=1188 + _STATE._serialized_start=1190 + _STATE._serialized_end=1248 + _ROLE._serialized_start=1251 + _ROLE._serialized_end=1384 + _ACTION._serialized_start=1387 + _ACTION._serialized_end=1580 + _OFFENSIVESIDE._serialized_start=1582 + _OFFENSIVESIDE._serialized_end=1665 + _FVEC2._serialized_start=78 + _FVEC2._serialized_end=107 + _FVEC3._serialized_start=109 + _FVEC3._serialized_end=149 + _FMAT3._serialized_start=151 + _FMAT3._serialized_end=266 + _ROBOT._serialized_start=269 + _ROBOT._serialized_end=421 + _BALL._serialized_start=424 + _BALL._serialized_end=561 + _MESSAGE._serialized_start=564 + _MESSAGE._serialized_end=1143 +# @@protoc_insertion_point(module_scope) diff --git a/controllers/referee/data_collection/post_processing/robocup_extension_pb2.pyi b/controllers/referee/data_collection/post_processing/robocup_extension_pb2.pyi new file mode 100644 index 00000000..e5be0e84 --- /dev/null +++ b/controllers/referee/data_collection/post_processing/robocup_extension_pb2.pyi @@ -0,0 +1,366 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" +import builtins +import collections.abc +import google.protobuf.descriptor +import google.protobuf.internal.containers +import google.protobuf.internal.enum_type_wrapper +import google.protobuf.message +import google.protobuf.timestamp_pb2 +import sys +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +class _Team: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _TeamEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_Team.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + UNKNOWN_TEAM: _Team.ValueType # 0 + BLUE: _Team.ValueType # 1 + RED: _Team.ValueType # 2 + +class Team(_Team, metaclass=_TeamEnumTypeWrapper): + """/ The detected team of the robot""" + +UNKNOWN_TEAM: Team.ValueType # 0 +BLUE: Team.ValueType # 1 +RED: Team.ValueType # 2 +global___Team = Team + +class _State: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _StateEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_State.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + UNKNOWN_STATE: _State.ValueType # 0 + UNPENALISED: _State.ValueType # 1 + PENALISED: _State.ValueType # 2 + +class State(_State, metaclass=_StateEnumTypeWrapper): + """/ The current playing state of the robot""" + +UNKNOWN_STATE: State.ValueType # 0 +UNPENALISED: State.ValueType # 1 +PENALISED: State.ValueType # 2 +global___State = State + +class _Role: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _RoleEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_Role.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + ROLE_UNDEFINED: _Role.ValueType # 0 + ROLE_IDLING: _Role.ValueType # 1 + ROLE_OTHER: _Role.ValueType # 2 + ROLE_STRIKER: _Role.ValueType # 3 + ROLE_SUPPORTER: _Role.ValueType # 4 + ROLE_DEFENDER: _Role.ValueType # 5 + ROLE_GOALIE: _Role.ValueType # 6 + +class Role(_Role, metaclass=_RoleEnumTypeWrapper): + """/ The role of the robot""" + +ROLE_UNDEFINED: Role.ValueType # 0 +ROLE_IDLING: Role.ValueType # 1 +ROLE_OTHER: Role.ValueType # 2 +ROLE_STRIKER: Role.ValueType # 3 +ROLE_SUPPORTER: Role.ValueType # 4 +ROLE_DEFENDER: Role.ValueType # 5 +ROLE_GOALIE: Role.ValueType # 6 +global___Role = Role + +class _Action: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _ActionEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_Action.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + ACTION_UNDEFINED: _Action.ValueType # 0 + ACTION_POSITIONING: _Action.ValueType # 1 + ACTION_GOING_TO_BALL: _Action.ValueType # 2 + ACTION_TRYING_TO_SCORE: _Action.ValueType # 3 + ACTION_WAITING: _Action.ValueType # 4 + ACTION_KICKING: _Action.ValueType # 5 + ACTION_SEARCHING: _Action.ValueType # 6 + ACTION_LOCALIZING: _Action.ValueType # 7 + +class Action(_Action, metaclass=_ActionEnumTypeWrapper): + """/ The current action of the robot""" + +ACTION_UNDEFINED: Action.ValueType # 0 +ACTION_POSITIONING: Action.ValueType # 1 +ACTION_GOING_TO_BALL: Action.ValueType # 2 +ACTION_TRYING_TO_SCORE: Action.ValueType # 3 +ACTION_WAITING: Action.ValueType # 4 +ACTION_KICKING: Action.ValueType # 5 +ACTION_SEARCHING: Action.ValueType # 6 +ACTION_LOCALIZING: Action.ValueType # 7 +global___Action = Action + +class _OffensiveSide: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _OffensiveSideEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_OffensiveSide.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + SIDE_UNDEFINED: _OffensiveSide.ValueType # 0 + SIDE_LEFT: _OffensiveSide.ValueType # 1 + SIDE_MIDDLE: _OffensiveSide.ValueType # 2 + SIDE_RIGHT: _OffensiveSide.ValueType # 3 + +class OffensiveSide(_OffensiveSide, metaclass=_OffensiveSideEnumTypeWrapper): + """/ The offensive strategy of the robot""" + +SIDE_UNDEFINED: OffensiveSide.ValueType # 0 +SIDE_LEFT: OffensiveSide.ValueType # 1 +SIDE_MIDDLE: OffensiveSide.ValueType # 2 +SIDE_RIGHT: OffensiveSide.ValueType # 3 +global___OffensiveSide = OffensiveSide + +@typing_extensions.final +class fvec2(google.protobuf.message.Message): + """/ A column vector of two floats""" + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + X_FIELD_NUMBER: builtins.int + Y_FIELD_NUMBER: builtins.int + x: builtins.float + y: builtins.float + def __init__( + self, + *, + x: builtins.float = ..., + y: builtins.float = ..., + ) -> None: ... + def ClearField(self, field_name: typing_extensions.Literal["x", b"x", "y", b"y"]) -> None: ... + +global___fvec2 = fvec2 + +@typing_extensions.final +class fvec3(google.protobuf.message.Message): + """/ A column vector of three floats""" + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + X_FIELD_NUMBER: builtins.int + Y_FIELD_NUMBER: builtins.int + Z_FIELD_NUMBER: builtins.int + x: builtins.float + y: builtins.float + z: builtins.float + def __init__( + self, + *, + x: builtins.float = ..., + y: builtins.float = ..., + z: builtins.float = ..., + ) -> None: ... + def ClearField(self, field_name: typing_extensions.Literal["x", b"x", "y", b"y", "z", b"z"]) -> None: ... + +global___fvec3 = fvec3 + +@typing_extensions.final +class fmat3(google.protobuf.message.Message): + """/ A matrix of three vectors + / Specified as column vectors + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + X_FIELD_NUMBER: builtins.int + Y_FIELD_NUMBER: builtins.int + Z_FIELD_NUMBER: builtins.int + @property + def x(self) -> global___fvec3: ... + @property + def y(self) -> global___fvec3: ... + @property + def z(self) -> global___fvec3: ... + def __init__( + self, + *, + x: global___fvec3 | None = ..., + y: global___fvec3 | None = ..., + z: global___fvec3 | None = ..., + ) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["x", b"x", "y", b"y", "z", b"z"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["x", b"x", "y", b"y", "z", b"z"]) -> None: ... + +global___fmat3 = fmat3 + +@typing_extensions.final +class Robot(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + PLAYER_ID_FIELD_NUMBER: builtins.int + POSITION_FIELD_NUMBER: builtins.int + COVARIANCE_FIELD_NUMBER: builtins.int + TEAM_FIELD_NUMBER: builtins.int + player_id: builtins.int + """/ ID of the robot, 0 if not known""" + @property + def position(self) -> global___fvec3: + """/ The position of the robot on the field according to the following convention + / x meters along the field with 0 at the centre of the field and positive towards opponent goals + / y meters across the field with 0 at the centre of the field and positive to the left + / θ orientation of the robot (anti-clockwise from the x axis from above the field) + """ + @property + def covariance(self) -> global___fmat3: + """/ The covariance measure of the robots [x, y, θ] values + / If this is unavailable leave this unset + """ + team: global___Team.ValueType + """/ Robot team, if known""" + def __init__( + self, + *, + player_id: builtins.int = ..., + position: global___fvec3 | None = ..., + covariance: global___fmat3 | None = ..., + team: global___Team.ValueType = ..., + ) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["covariance", b"covariance", "position", b"position"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["covariance", b"covariance", "player_id", b"player_id", "position", b"position", "team", b"team"]) -> None: ... + +global___Robot = Robot + +@typing_extensions.final +class Ball(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + POSITION_FIELD_NUMBER: builtins.int + VELOCITY_FIELD_NUMBER: builtins.int + COVARIANCE_FIELD_NUMBER: builtins.int + @property + def position(self) -> global___fvec3: + """/ The position of the ball on the field according to the following convention + / x meters along the field with 0 at the centre of the field and positive towards opponent goals + / y meters across the field with 0 at the centre of the field and positive to the left + / z meters above the field with 0 at the surface of the field and positive up + """ + @property + def velocity(self) -> global___fvec3: + """/ The velocity of the ball + / x m/s along the field with 0 at the centre of the field and positive towards opponent goals + / y m/s across the field with 0 at the centre of the field and positive to the left + / z m/s above the field with 0 at the surface of the field and positive up + / Set to 0 if not available + """ + @property + def covariance(self) -> global___fmat3: + """/ The covariance measure of the balls [x, y, z] values + / If this is unavailable leave this unset + """ + def __init__( + self, + *, + position: global___fvec3 | None = ..., + velocity: global___fvec3 | None = ..., + covariance: global___fmat3 | None = ..., + ) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["covariance", b"covariance", "position", b"position", "velocity", b"velocity"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["covariance", b"covariance", "position", b"position", "velocity", b"velocity"]) -> None: ... + +global___Ball = Ball + +@typing_extensions.final +class Message(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + TIMESTAMP_FIELD_NUMBER: builtins.int + STATE_FIELD_NUMBER: builtins.int + CURRENT_POSE_FIELD_NUMBER: builtins.int + WALK_COMMAND_FIELD_NUMBER: builtins.int + TARGET_POSE_FIELD_NUMBER: builtins.int + KICK_TARGET_FIELD_NUMBER: builtins.int + BALL_FIELD_NUMBER: builtins.int + OTHERS_FIELD_NUMBER: builtins.int + MAX_WALKING_SPEED_FIELD_NUMBER: builtins.int + TIME_TO_BALL_FIELD_NUMBER: builtins.int + ROLE_FIELD_NUMBER: builtins.int + ACTION_FIELD_NUMBER: builtins.int + OFFENSIVE_SIDE_FIELD_NUMBER: builtins.int + OTHER_ROBOT_CONFIDENCE_FIELD_NUMBER: builtins.int + @property + def timestamp(self) -> google.protobuf.timestamp_pb2.Timestamp: + """/ Timestamp of message creation""" + state: global___State.ValueType + """/ The robots current state""" + @property + def current_pose(self) -> global___Robot: + """/ Position, orientation, and covariance of the player on the field""" + @property + def walk_command(self) -> global___fvec3: + """/ The current walk speed of the robot in it's local [x, y, θ] coordinates + / x and y in m/s and θ in rad/s + / positive x being forwards, positive y being strafing to the left, and positive θ being anti-clockwise + """ + @property + def target_pose(self) -> global___Robot: + """/ Position and orientation of the players target on the field specified""" + @property + def kick_target(self) -> global___fvec2: + """/ Position that the robot is aiming to kick the ball to + / If no kick is planned set to [0, 0] + / Vector has origin on the ground between the robots feet + """ + @property + def ball(self) -> global___Ball: + """/ Position, velocity, and covariance of the ball on the field""" + @property + def others(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Robot]: + """/ Position, orientation, and covariance of detected robots on the field""" + max_walking_speed: builtins.float + """*************************** + EXTENSIONS GO BELOW HERE * + ************************** + + / Maximum walking speed of the robot + """ + time_to_ball: builtins.float + """/ Time the robot needs to reach the ball;""" + role: global___Role.ValueType + """/ The role of the robot""" + action: global___Action.ValueType + """/ The current action of the robot""" + offensive_side: global___OffensiveSide.ValueType + """/ The offensive strategy of the robot""" + @property + def other_robot_confidence(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.float]: + """/ Confidence values of the obstacles""" + def __init__( + self, + *, + timestamp: google.protobuf.timestamp_pb2.Timestamp | None = ..., + state: global___State.ValueType = ..., + current_pose: global___Robot | None = ..., + walk_command: global___fvec3 | None = ..., + target_pose: global___Robot | None = ..., + kick_target: global___fvec2 | None = ..., + ball: global___Ball | None = ..., + others: collections.abc.Iterable[global___Robot] | None = ..., + max_walking_speed: builtins.float = ..., + time_to_ball: builtins.float = ..., + role: global___Role.ValueType = ..., + action: global___Action.ValueType = ..., + offensive_side: global___OffensiveSide.ValueType = ..., + other_robot_confidence: collections.abc.Iterable[builtins.float] | None = ..., + ) -> None: ... + def HasField(self, field_name: typing_extensions.Literal["ball", b"ball", "current_pose", b"current_pose", "kick_target", b"kick_target", "target_pose", b"target_pose", "timestamp", b"timestamp", "walk_command", b"walk_command"]) -> builtins.bool: ... + def ClearField(self, field_name: typing_extensions.Literal["action", b"action", "ball", b"ball", "current_pose", b"current_pose", "kick_target", b"kick_target", "max_walking_speed", b"max_walking_speed", "offensive_side", b"offensive_side", "other_robot_confidence", b"other_robot_confidence", "others", b"others", "role", b"role", "state", b"state", "target_pose", b"target_pose", "time_to_ball", b"time_to_ball", "timestamp", b"timestamp", "walk_command", b"walk_command"]) -> None: ... + +global___Message = Message diff --git a/controllers/referee/data_collection/pytests/__init__.py b/controllers/referee/data_collection/pytests/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/controllers/referee/data_collection/pytests/test_data_collector.py b/controllers/referee/data_collection/pytests/test_data_collector.py new file mode 100644 index 00000000..9bcd549a --- /dev/null +++ b/controllers/referee/data_collection/pytests/test_data_collector.py @@ -0,0 +1,77 @@ +import glob +import os +import time + +from data_collection import match_info as mi +from data_collection.data_collector import DataCollector +from data_collection.pytests.test_static import _create_static_match_info +from data_collection.pytests.test_step import _create_step + + +def _create_data_collector(tmp_path) -> DataCollector: + save_dir = tmp_path + + match = mi.Match(_create_static_match_info()) + + data_collector = DataCollector(save_dir, 5, match) + + assert data_collector.save_dir == save_dir + assert data_collector.match == match + assert data_collector.autosave_interval == 5 + assert data_collector.match.get_static_match_info() == match.get_static_match_info() + assert data_collector.match.get_steps() == match.get_steps() == [] + + return data_collector + + +def test_create_data_collector(tmp_path): + d = _create_data_collector(tmp_path) + # Check for empty directory before first autosave + assert len(os.listdir(d.save_dir)) == 0 + + time.sleep(10) + + # Check if data was saved + assert ( + len(os.listdir(d.save_dir)) + == len( + glob.glob( + os.path.join(d.save_dir, "referee_data_collection_AUTOSAVE_*.json") + ) + ) + == 1 + ), "Only a static match info file should be saved (referee_data_collection_AUTOSAVE_*.json)" + + # Add a few steps to the match + for i in range(5): + d.match.add_step(_create_step(i)) + + time.sleep(10) + + # Check if data was saved + assert ( + len(os.listdir(d.save_dir)) + == len( + glob.glob(os.path.join(d.save_dir, "referee_data_collection_AUTOSAVE_*")) + ) + == 3 + ), "A static match info .json file and two dynamic match info (.feather and .pkl) file should be saved" + + # Close data collector + d.finalize() + + # Check if data was saved + assert ( + len(os.listdir(d.save_dir)) == 6 + ), "Six files (.json, .feather and .pkl) should be saved, tree for each autosave and one for the final save" + assert ( + len(glob.glob(os.path.join(d.save_dir, "referee_data_collection_COMPLETE_*"))) + == 3 + ), "Three files should be saved for the final save (referee_data_collection_complete_* [.json, .feather and .pkl])" + + +# TODO: Test data collector failure case (__del__) + + +if __name__ == "__main__": + test_create_data_collector("REPLACE_WITH_PATH") diff --git a/controllers/referee/data_collection/pytests/test_static.py b/controllers/referee/data_collection/pytests/test_static.py new file mode 100644 index 00000000..3776205d --- /dev/null +++ b/controllers/referee/data_collection/pytests/test_static.py @@ -0,0 +1,68 @@ +import data_collection.match_info as mi + + +# Create a test StaticMatchInfo object +def _create_static_match_info(id: str = "test_id") -> mi.StaticMatchInfo: + match_type = mi.MatchType.ROUNDROBIN + league_sub_type = mi.LeagueSubType.KID + simulation = mi.Simulation(True, 0, 8) + field = mi.Field("test_location_id", "test_location_name", 6.0, 9.0, 1.0) + ball = mi.StaticBall("test_ball_id", 0.5, "test_ball_texture", 0.14) + teams = mi.StaticTeams( + mi.StaticTeam( + "test_team_1", + "test_team_1_name", + mi.TeamColor.RED, + mi.StaticPlayer("test_player_1", 0.5, 20, "test_platform_1", mi.Camera("test_camera_1", 42, 1.0, 42, 42)), + mi.StaticPlayer("test_player_2", 0.5, 20, "test_platform_2", mi.Camera("test_camera_2", 42, 1.0, 42, 42)), + mi.StaticPlayer("test_player_3", 0.5, 20, "test_platform_3", mi.Camera("test_camera_3", 42, 1.0, 42, 42)), + mi.StaticPlayer("test_player_4", 0.5, 20, "test_platform_4", mi.Camera("test_camera_4", 42, 1.0, 42, 42)) + ), + mi.StaticTeam( + "test_team_2", + "test_team_2_name", + mi.TeamColor.BLUE, + mi.StaticPlayer("test_player_5", 0.5, 20, "test_platform_5", mi.Camera("test_camera_5", 42, 1.0, 42, 42)), + mi.StaticPlayer("test_player_6", 0.5, 20, "test_platform_6", mi.Camera("test_camera_6", 42, 1.0, 42, 42)), + mi.StaticPlayer("test_player_7", 0.5, 20, "test_platform_7", mi.Camera("test_camera_7", 42, 1.0, 42, 42)), + mi.StaticPlayer("test_player_8", 0.5, 20, "test_platform_8", mi.Camera("test_camera_8", 42, 1.0, 42, 42)) + ) + ) + kick_off_team = "test_team_1" + + static_match_info = mi.StaticMatchInfo( + id, match_type, league_sub_type, simulation, field, ball, teams, kick_off_team + ) + + assert static_match_info.id == id + assert static_match_info.match_type == match_type + assert static_match_info.league_sub_type == league_sub_type + assert static_match_info.simulation == simulation + assert static_match_info.field == field + assert static_match_info.ball == ball + assert static_match_info.teams == teams + + return static_match_info + + +def test_create_static_match_info(): + _create_static_match_info() + + +def test_json_dump_and_load_static_match_info(): + static_match_info = _create_static_match_info() + + # Dump the object to a JSON string + json_string = static_match_info.to_json() # type: ignore + + # Load the object from the JSON string + json_static_match_info = mi.StaticMatchInfo.from_json(json_string) + + assert ( + json_static_match_info == static_match_info + ), f"StaticMatchInfo does not match:\nFROM JSON: {json_static_match_info}\nFROM OBJECT: {static_match_info}" + + +if __name__ == "__main__": + test_create_static_match_info() + test_json_dump_and_load_static_match_info() diff --git a/controllers/referee/data_collection/pytests/test_step.py b/controllers/referee/data_collection/pytests/test_step.py new file mode 100644 index 00000000..47fdaf1d --- /dev/null +++ b/controllers/referee/data_collection/pytests/test_step.py @@ -0,0 +1,99 @@ +import data_collection.match_info as mi + +# from forceful_contact_matrix import ForcefulContactMatrix + + +def _create_step(time: int) -> mi.Step: + delta_real_time: float = 0.1 + + game_control_data = mi.GameControlData( + game_state=mi.GameControlData.GameState.STATE_INITIAL, + first_half=True, + kickoff_team=1, + secondary_state=mi.GameControlData.SecondaryGameState.STATE_UNKNOWN, + secondary_state_info_team=1, + secondary_state_info_sub_state=1, + drop_in_team=True, + drop_in_time=0, + seconds_remaining=0, + secondary_seconds_remaining=0, + ) + + ball: mi.Ball = mi.Ball( + "ball_id", + mi.Frame("BALL_SHAPE", mi.Pose(mi.Position(0, 0, 0), mi.Rotation(0, 0, 0, 1))), + ) + player: mi.Player = mi.Player( + "player_1", + mi.Frame( + "base_link", + mi.Pose(mi.Position(0, 0, 0), mi.Rotation(0, 0, 0, 1)), + ), + mi.Frame( + "l_sole", + mi.Pose(mi.Position(0, 0, 0), mi.Rotation(0, 0, 0, 1)), + ), + mi.Frame( + "r_sole", + mi.Pose(mi.Position(0, 0, 0), mi.Rotation(0, 0, 0, 1)), + ), + mi.Frame( + "l_gripper", + mi.Pose(mi.Position(0, 0, 0), mi.Rotation(0, 0, 0, 1)), + ), + mi.Frame( + "r_gripper", + mi.Pose(mi.Position(0, 0, 0), mi.Rotation(0, 0, 0, 1)), + ), + camera_frame=mi.Frame( + "camera", + mi.Pose(mi.Position(0, 0, 0), mi.Rotation(0, 0, 0, 1)), + ), + state=mi.State.UNKNOWN_STATE, + role=mi.Role.ROLE_UNDEFINED, + action=mi.Action.ACTION_UNDEFINED, + robot_info=mi.RobotInfo( + mi.Penalty.UNKNOWN, + secs_till_unpenalized=42, + number_of_warnings=42, + number_of_yellow_cards=42, + number_of_red_cards=42, + goalkeeper=False + ) + ) + teams: mi.Teams = mi.Teams( + mi.Team("HSV", player1=player), mi.Team("St. Pauli", player2=player) + ) + + step = mi.Step( + time, + delta_real_time=delta_real_time, + ball=ball, + teams=teams, + ) + + assert step.time == time + assert step.delta_real_time == delta_real_time + assert step.ball == ball + assert step.teams == teams + + return step + + +def test_create_step(): + assert _create_step(0) is not None + + +def test_convert_steps_to_dataframe(): + import pandas as pd + + steps = [_create_step(i) for i in range(10)] + + df = pd.json_normalize([step.to_dict() for step in steps]) + + assert len(df) == len(steps) + + +if __name__ == "__main__": + test_create_step() + test_convert_steps_to_dataframe() diff --git a/controllers/referee/field.py b/controllers/referee/field.py index 4ff1c784..4d4dbfb0 100644 --- a/controllers/referee/field.py +++ b/controllers/referee/field.py @@ -27,7 +27,7 @@ def __init__(self, size): self.circle_radius = 0.75 if size == 'kid' else 1.5 self.penalty_offset = 0.6 if size == 'kid' else 1 self.opponent_distance_to_ball = 0.75 if size == 'kid' else 1.5 - self.ball_vincity = 0.375 if size == 'kid' else 0.75 + self.ball_vicinity = 0.375 if size == 'kid' else 0.75 self.robot_radius = 0.3 if size == 'kid' else 0.5 self.place_ball_safety_dist = 0.5 if size == 'kid' else 1.0 self.turf_depth = 0.01 diff --git a/controllers/referee/game.json b/controllers/referee/game.json index a5377ca7..ec265369 100644 --- a/controllers/referee/game.json +++ b/controllers/referee/game.json @@ -7,6 +7,12 @@ "side_left": "blue", "press_a_key_to_terminate": true, "use_bouncing_server": true, + "data_collection": { + "enabled": true, + "directory": "./data", + "step_interval": 8, + "autosave_interval": 600 + }, "red": { "id": 8, "config": "team_1.json", diff --git a/controllers/referee/gamestate.py b/controllers/referee/gamestate.py index 38b5645a..689c61ef 100644 --- a/controllers/referee/gamestate.py +++ b/controllers/referee/gamestate.py @@ -24,15 +24,15 @@ Short = Int16ul RobotInfo = "robot_info" / Struct( - # NONE 0 - # PENALTY_HL_KID_BALL_MANIPULATION 1 - # PENALTY_HL_KID_PHYSICAL_CONTACT 2 - # PENALTY_HL_KID_ILLEGAL_ATTACK 3 - # PENALTY_HL_KID_ILLEGAL_DEFENSE 4 - # PENALTY_HL_KID_REQUEST_FOR_PICKUP 5 - # PENALTY_HL_KID_REQUEST_FOR_SERVICE 6 - # PENALTY_HL_KID_REQUEST_FOR_PICKUP_2_SERVICE 7 - # MANUAL 15 + # Updated from https://github.com/RoboCup-Humanoid-TC/GameController/blob/master/src/data/values/Penalties.java + # UNKNOWN 255 + # NONE 0 + # SUBSTITUTE 14 + # MANUAL 15 + # HL_BALL_MANIPULATION 30 + # HL_PHYSICAL_CONTACT 31 + # HL_PICKUP_OR_INCAPABLE 34 + # HL_SERVICE 35 "penalty" / Byte, "secs_till_unpenalized" / Byte, "number_of_warnings" / Byte, diff --git a/controllers/referee/referee.py b/controllers/referee/referee.py index 0c19fe8c..3464b5dc 100644 --- a/controllers/referee/referee.py +++ b/controllers/referee/referee.py @@ -29,19 +29,26 @@ from scipy.spatial import ConvexHull from types import SimpleNamespace +from typing import Dict, List, Optional -from controller import Supervisor, Node -from gamestate import GameState +import numpy as np +import yaml + +import data_collection as dc +import data_collection.match_info as mi +from blackboard import blackboard +from controller import Node, Supervisor +from display import Display from field import Field from forceful_contact_matrix import ForcefulContactMatrix from logger import logger +from gamestate import GameState from geometry import distance2, rotate_along_z, aabb_circle_collision, polygon_circle_collision, update_aabb from display import Display from game import Game from team import Team from sim_time import SimTime -from blackboard import blackboard # game interruptions requiring a free kick procedure @@ -57,6 +64,7 @@ class Referee: def __init__(self): + # start the webots supervisor self.supervisor = Supervisor() self.time_step = int(self.supervisor.getBasicTimeStep()) @@ -74,6 +82,8 @@ def __init__(self): self.game_controller_socket = None + self.first_step_done = False + self.blackboard = blackboard self.blackboard.supervisor = self.supervisor self.blackboard.sim_time = self.sim_time @@ -128,6 +138,16 @@ def __init__(self): self.setup() self.display.update() + if self.game.data_collection["enabled"]: + try: + self.gather_data_collection_frame_nodes() + self.data_collector: dc.DataCollector = self.init_data_collector() + self.logger.info("Data collection setup complete.") + except Exception: + self.game.data_collection["enabled"] = False # disable data collection + self.logger.error(f"Unexpected exception while initializing data collector: {traceback.format_exc()}") + + self.status_update_last_real_time = None self.status_update_last_sim_time = None @@ -138,6 +158,109 @@ def __init__(self): self.clean_exit() + def init_data_collector(self) -> dc.DataCollector: + """Initializes the data collector.""" + + def create_static_players(players) -> Dict[int, Optional[mi.StaticPlayer]]: + """Creates a dict of static players from list of players (from team.json). + Keys are int indexes derived from sorted player IDs. + This is to ensure that the order of players is consistent across runs. + Example: Sorted player IDs are 2, 5, 6, 9. Keys will be 0, 1, 2, 3. + + :param players: List of players (from team.json) + :return: Dict of static players + :rtype: Dict[int, Optional[mi.StaticPlayer]] + """ + static_players = {} + + for idx, player_id in enumerate(sorted(players.keys())): # Sort by player ID to consistently match to player1-4 + static_players[idx] = mi.StaticPlayer( + id = str(player_id), + mass = -1.0, # TODO Add mass manually (currently not possible with supervisor) + DOF = -1, # TODO Add DOF manually + platform = players[player_id]['proto'], + # TODO: Add Cameras manually + ) + return static_players + + match_id = os.environ.get("HLVS_GAME_TAG", "UNKNOWN_HLVS_GAME_TAG").strip() + + # Match type + match_type = mi.MatchType.UNKNOWN + if self.game.type == 'NORMAL': match_type = mi.MatchType.ROUNDROBIN + if self.game.type == 'KNOCKOUT': match_type = mi.MatchType.PLAYOFF + if self.game.type == 'PENALTY': match_type = mi.MatchType.PENALTY + + # League type + # Alternatively, this could be read from the game config file (self.game.class), + # but it seems like this is not used elsewhere in this referee. + league_sub_type = mi.LeagueSubType.ADULT + if self.game.field_size == "kid": league_sub_type = mi.LeagueSubType.KID + + simulation: mi.Simulation = mi.Simulation(True, self.time_step, self.game.data_collection["step_interval"]) + + field = mi.Field( + location_id = self.background, + location_name = self.background, + size_x = self.field.size_x * 2, # Sizes are of half field + size_y = self.field.size_y * 2, # Sizes are of half field + luminosity = self.luminosity, + ) + + ball = mi.StaticBall( + id = "BALL", + mass = -1.0, # TODO Add mass manually (currently not possible with supervisor) + texture = self.ball_texture, + diameter = self.game.ball_radius * 2, + ) + + team1_players = create_static_players(self.blue_team.players) + team2_players = create_static_players(self.red_team.players) + + # Team 1 is always blue + teams = mi.StaticTeams( + team1 = mi.StaticTeam( + id = str(self.game.blue.id), + name = self.blue_team.name, + color = mi.TeamColor.BLUE, + player1 = team1_players.get(0, None), + player2 = team1_players.get(1, None), + player3 = team1_players.get(2, None), + player4 = team1_players.get(3, None), + ), + + # Team 2 is always red + team2 = mi.StaticTeam( + id = str(self.game.red.id), + name = self.red_team.name, + color = mi.TeamColor.RED, + player1 = team2_players.get(0, None), + player2 = team2_players.get(1, None), + player3 = team2_players.get(2, None), + player4 = team2_players.get(3, None), + ), + ) + + static_match_info: mi.StaticMatchInfo = mi.StaticMatchInfo( + match_id, + match_type, + league_sub_type, + simulation, + field, + ball, + teams, + self.game.kickoff, + ) + + match = mi.Match(static_match_info) + + return dc.DataCollector( + self.game.data_collection["directory"], + self.game.data_collection["autosave_interval"], + match, + self.logger, + ) + def announce_final_score(self): """ Prints score of the match to the console and saves it to the log. """ if not hasattr(self.game, "state"): @@ -161,6 +284,9 @@ def clean_exit(self): if hasattr(self.game, "udp_bouncer_process") and self.udp_bouncer_process: self.logger.info("Terminating 'udp_bouncer' process") self.udp_bouncer_process.terminate() + if hasattr(self, "data_collector") and self.game.data_collection["enabled"]: + self.logger.info("Stopping 'data collection'") + self.data_collector.finalize() if hasattr(self.game, 'over') and self.game.over: self.logger.info("Game is over") if hasattr(self.game, 'press_a_key_to_terminate') and self.game.press_a_key_to_terminate: @@ -187,7 +313,7 @@ def clean_exit(self): while not self.supervisor.movieIsReady(): self.supervisor.step(self.time_step) self.logger.info("Encoding finished") - self.logger.info("Exiting webots properly") + self.logger.info("Exiting Webots properly") # Note: If self.supervisor.step is not called before the 'simulationQuit', information is not shown self.supervisor.step(self.time_step) @@ -254,10 +380,10 @@ def spawn_team(self, team, red_on_right): port = self.game.red.ports[n] if color == 'red' else self.game.blue.ports[n] if red_on_right: # symmetry with respect to the central line of the field self.flip_poses(player) - defname = color.upper() + '_PLAYER_' + number + def_name = color.upper() + '_PLAYER_' + number halfTimeStartingTranslation = player['halfTimeStartingPose']['translation'] halfTimeStartingRotation = player['halfTimeStartingPose']['rotation'] - string = f'DEF {defname} {model}{{name "{color} player {number}" ' + \ + string = f'DEF {def_name} {model}{{name "{color} player {number}" ' + \ f'translation {halfTimeStartingTranslation[0]} ' + \ f'{halfTimeStartingTranslation[1]} {halfTimeStartingTranslation[2]} ' + \ f'rotation {halfTimeStartingRotation[0]} ' + \ @@ -268,9 +394,9 @@ def spawn_team(self, team, red_on_right): string += f', "{h}"' string += '] }' children.importMFNodeFromString(-1, string) - player['robot'] = self.supervisor.getFromDef(defname) + player['robot'] = self.supervisor.getFromDef(def_name) player['position'] = player['robot'].getCenterOfMass() - self.logger.info(f'Spawned {defname} {model} on port {port} at halfTimeStartingPose: translation (' + + self.logger.info(f'Spawned {def_name} {model} on port {port} at halfTimeStartingPose: translation (' + f'{halfTimeStartingTranslation[0]} {halfTimeStartingTranslation[1]} ' + f'{halfTimeStartingTranslation[2]}), rotation ({halfTimeStartingRotation[0]} ' + f'{halfTimeStartingRotation[1]} {halfTimeStartingRotation[2]} {halfTimeStartingRotation[3]}).') @@ -576,14 +702,14 @@ def update_team_ball_holding(self, team): goalkeeper_number = None for number, player in team.players.items(): d = distance2(player['position'], self.game.ball_position) - if d <= self.field.ball_vincity: + if d <= self.field.ball_vicinity: if self.is_goalkeeper(team, number): goalkeeper_number = number players_close_to_the_ball.append(player) numbers.append(number) goalkeeper_hold_ball = False - if goalkeeper_number is not None: # goalkeeper is in vincity of ball + if goalkeeper_number is not None: # goalkeeper is in vicinity of ball goalkeeper = team.players[goalkeeper_number] points = np.empty([4, 2]) aabb = None @@ -677,7 +803,7 @@ def update_team_contacts(self, team): # if less then 3 contact points, the contacts do not include contacts with the ground, # so don't update the following value based on ground collisions if n >= 3: - player['outside_circle'] = True # true if fully outside the center cicle + player['outside_circle'] = True # true if fully outside the center circle player['outside_field'] = True # true if fully outside the field player['inside_field'] = True # true if fully inside the field player['on_outer_line'] = False # true if robot is partially on the line surrounding the field @@ -921,8 +1047,8 @@ def forceful_contact_foul(self, team, number, opponent_team, opponent_number, di if foul_far_from_ball or not self.game.in_play or self.game.penalty_shootout: self.send_penalty(player, 'PHYSICAL_CONTACT', 'forceful contact foul') else: - offence_location = team.players[number]['position'] - self.interruption('FREEKICK', freekick_team_id, offence_location) + offense_location = team.players[number]['position'] + self.interruption('FREEKICK', freekick_team_id, offense_location) def goalkeeper_inside_own_goal_area(self, team, number): if self.is_goalkeeper(team, number): @@ -971,7 +1097,7 @@ def check_team_forceful_contacts(self, team, number, opponent_team, opponent_num red_number = opponent_number blue_number = number if self.forceful_contact_matrix.long_collision(red_number, blue_number): - if d1 < self.config.FOUL_VINCITY_DISTANCE and d1 - d2 > self.config.FOUL_DISTANCE_THRESHOLD: + if d1 < self.config.FOUL_VICINITY_DISTANCE and d1 - d2 > self.config.FOUL_DISTANCE_THRESHOLD: collision_time = self.forceful_contact_matrix.get_collision_time(red_number, blue_number) debug_messages.append(f"Pushing time: {collision_time} > {self.config.FOUL_PUSHING_TIME} " f"over the last {self.config.FOUL_PUSHING_PERIOD}") @@ -989,8 +1115,8 @@ def check_team_forceful_contacts(self, team, number, opponent_team, opponent_num f"speed: {math.sqrt(v1_squared):.2f}") debug_messages.append(f"{p2_str:6s}: velocity: {self.readable_number_list(v2[:3])}, " f"speed: {math.sqrt(v2_squared):.2f}") - if d1 < self.config.FOUL_VINCITY_DISTANCE: - debug_messages.append(f"{p1_str} is close to the ball ({d1:.2f} < {self.config.FOUL_VINCITY_DISTANCE})") + if d1 < self.config.FOUL_VICINITY_DISTANCE: + debug_messages.append(f"{p1_str} is close to the ball ({d1:.2f} < {self.config.FOUL_VICINITY_DISTANCE})") if self.moves_to_ball(p2, v2, v2_squared): if not self.moves_to_ball(p1, v1, v1_squared): self.logger.info(debug_messages) @@ -1319,7 +1445,7 @@ def check_circle_entrance(self, team): continue if not player['outside_circle']: color = team.color - self.send_penalty(player, 'INCAPABLE', 'entered circle during oppenent\'s kick-off', + self.send_penalty(player, 'INCAPABLE', 'entered circle during opponent\'s kick-off', f'{color.capitalize()} player {number} entering circle during opponent\'s kick-off.') penalty = True return penalty @@ -1378,7 +1504,7 @@ def game_interruption_touched(self, team, number): def game_interruption_ball_holding(self, team): """ - Applies the associated actions for when a robot does ball holding duing an interruption + Applies the associated actions for when a robot does ball holding during an interruption 1. If opponent commits ball holding, RETAKE is sent 2. If team with game_interruption does ball holding game interruption continues @@ -1644,7 +1770,7 @@ def next_penalty_shootout(self): self.logger.info('Starting extended penalty shootout without a goalkeeper and goal area entrance allowed.') # Only prepare next penalty if team has a kicker available self.flip_sides() - self.logger.info(f'fliped sides: game.side_left = {self.game.side_left}') + self.logger.info(f'Flipped sides: game.side_left = {self.game.side_left}') if self.penalty_kicker_player(): self.game_controller_send('STATE:SET') self.set_penalty_positions() @@ -1807,25 +1933,25 @@ def penalize_fallen_robots_near(self, position, min_dist): def get_alternative_ball_locations(self, original_pos): if (self.game.interruption_team == self.game.red.id) ^ (self.game.side_left == self.game.blue.id): - prefered_x_dir = 1 + preferred_x_dir = 1 else: - prefered_x_dir = -1 - prefered_y_dir = -1 if original_pos[1] > 0 else 1 - offset_x = prefered_x_dir * self.field.place_ball_safety_dist * np.array([1, 0, 0]) - offset_y = prefered_y_dir * self.field.place_ball_safety_dist * np.array([0, 1, 0]) + preferred_x_dir = -1 + preferred_y_dir = -1 if original_pos[1] > 0 else 1 + offset_x = preferred_x_dir * self.field.place_ball_safety_dist * np.array([1, 0, 0]) + offset_y = preferred_y_dir * self.field.place_ball_safety_dist * np.array([0, 1, 0]) locations = [] if self.game.interruption == "DIRECT_FREEKICK" or self.game.interruption == "INDIRECT_FREEKICK": # TODO If indirect free kick in opponent penalty area on line parallel to goal line, move it along this line - for dist_mult in range(1, self.config.GAME_INTERRUPTION_PLACEMENT_NB_STEPS+1): - locations.append(original_pos + offset_x * dist_mult) - locations.append(original_pos + offset_y * dist_mult) - locations.append(original_pos - offset_y * dist_mult) - locations.append(original_pos - offset_x * dist_mult) + for dist_multiplier in range(1, self.config.GAME_INTERRUPTION_PLACEMENT_NB_STEPS+1): + locations.append(original_pos + offset_x * dist_multiplier) + locations.append(original_pos + offset_y * dist_multiplier) + locations.append(original_pos - offset_y * dist_multiplier) + locations.append(original_pos - offset_x * dist_multiplier) elif self.game.interruption == "THROWIN": - for dist_mult in range(1, self.config.GAME_INTERRUPTION_PLACEMENT_NB_STEPS+1): - locations.append(original_pos + offset_x * dist_mult) - for dist_mult in range(1, self.config.GAME_INTERRUPTION_PLACEMENT_NB_STEPS+1): - locations.append(original_pos - offset_x * dist_mult) + for dist_multiplier in range(1, self.config.GAME_INTERRUPTION_PLACEMENT_NB_STEPS+1): + locations.append(original_pos + offset_x * dist_multiplier) + for dist_multiplier in range(1, self.config.GAME_INTERRUPTION_PLACEMENT_NB_STEPS+1): + locations.append(original_pos - offset_x * dist_multiplier) return locations def get_obstacles_positions(self, team, number): @@ -1853,9 +1979,9 @@ def move_robots_away(self, target_location): player_2_ball = [1, 0, 0] dist = 1 offset = player_2_ball / dist * self.field.place_ball_safety_dist - for dist_mult in range(1, self.config.GAME_INTERRUPTION_PLACEMENT_NB_STEPS+1): + for dist_multiplier in range(1, self.config.GAME_INTERRUPTION_PLACEMENT_NB_STEPS+1): allowed = True - pos = target_location + offset * dist_mult + pos = target_location + offset * dist_multiplier for o in obstacles: if distance2(o, pos) < self.field.place_ball_safety_dist: allowed = False @@ -1903,6 +2029,208 @@ def game_interruption_place_ball(self, target_location, enforce_distance=True): self.game.reset_ball_touched() self.logger.info(f'Ball respawned at {target_location[0]} {target_location[1]} {target_location[2]}.') + def gather_data_collection_frame_nodes(self): + """Collects the nodes of the ball's and team player's frames.""" + + def get_player_frame_nodes(team, number) -> Dict[str, Node]: + """Returns the nodes of frames from a player. + + :param team: team of the player + :param number: number of the player + :return: a dictionary of nodes indexed by frame id + :rtype: Dict[str, Node] + """ + frame_ids = [ + "base_link", + "l_sole", + "r_sole", + "l_gripper", + "r_gripper", + "camera_frame", + "l_camera_frame", + "r_camera_frame", + ] + robot = team.players[number]["robot"] + nodes = {} + for frame_id in frame_ids: + node = robot.getFromProtoDef(frame_id) + if node is None: + continue + #node.enablePoseTracking(self.time_step) + nodes[frame_id] = node + return nodes + + self.data_collection_frame_nodes = { + "ball": {}, + "teams": {}, + } + + # Ball + node = self.ball + #node.enablePoseTracking(self.time_step) + self.data_collection_frame_nodes["ball"] = {"BALL": node} + + # Teams + for color, team in {"blue": self.blue_team, "red": self.red_team}.items(): + self.data_collection_frame_nodes["teams"][color] = {} + for number in team.players.keys(): + self.data_collection_frame_nodes["teams"][color][number] = get_player_frame_nodes(team, number) + + def data_collection_set_ball_data(self): + """Sets the ball data for the data collection.""" + frame_id = "BALL" + affine_pose = self.data_collection_frame_nodes["ball"][frame_id].getPose() + + self.data_collector.current_step().ball = mi.Ball( + frame_id, + mi.Frame( + frame_id, + mi.pose_from_affine(np.array(affine_pose)), + ), + ) + + def data_collection_set_team_data(self): + """Sets the team data for the data collection.""" + + def create_player(player_number: str, game_info_team, players: Dict[str, Dict[str, List[float]]]) -> Optional[mi.Player]: + """Creates a player for the data collection. + + :param player_number: Number of the player + :type player_number: str + :param game_info_team: Team info from the game info + :type game_info_team: + :param players: Dict of players of poses + :type poses: Dict[str, Dict[str, List[float]]] + :return: Player object, if the player exists + :rtype: Optional[mi.Player] + """ + # Check if player exists + if not player_number in players: + return None + + # Get GameInfoPlayer from game info + game_info_player = game_info_team.players[int(player_number)] + + # Get RobotInfo from game state info + if self.game.state is not None: + robot_info = mi.RobotInfo( + penalty = game_info_player.penalty, + secs_till_unpenalized = game_info_player.secs_till_unpenalized, + number_of_warnings = game_info_player.number_of_warnings, + number_of_yellow_cards = game_info_player.number_of_yellow_cards, + number_of_red_cards = game_info_player.number_of_red_cards, + goalkeeper = game_info_player.goalkeeper, + ) + self.game.state.teams[0].score + else: + robot_info = None + + # Get poses + poses = players[player_number] + try: + camera_frame = mi.pose_from_affine(np.array(poses["camera_frame"])) + except KeyError: + camera_frame = None + try: + l_camera_frame = mi.pose_from_affine(np.array(poses["l_camera_frame"])) + except KeyError: + l_camera_frame = None + try: + r_camera_frame = mi.pose_from_affine(np.array(poses["r_camera_frame"])) + except KeyError: + r_camera_frame = None + + return mi.Player( + id=player_number, + base_link=mi.pose_from_affine(np.array(poses["base_link"])), + l_sole=mi.pose_from_affine(np.array(poses["l_sole"])), + r_sole=mi.pose_from_affine(np.array(poses["r_sole"])), + l_gripper=mi.pose_from_affine(np.array(poses["l_gripper"])), + r_gripper=mi.pose_from_affine(np.array(poses["r_gripper"])), + camera_frame=camera_frame, + l_camera_frame=l_camera_frame, + r_camera_frame=r_camera_frame, + robot_info=robot_info + ) + + def create_team(game_info_team, players) -> mi.Team: + """Create a team for the data collection. + + :param game_info_team: Team info from the game info + :type game_info_team: + :param players: Dict of players of poses + :type poses: Dict[str, Dict[str, List[float]]] + """ + return mi.Team( + id=game_info_team.team_number, + player1=create_player("1", game_info_team, players), + player2=create_player("2", game_info_team, players), + player3=create_player("3", game_info_team, players), + player4=create_player("4", game_info_team, players), + score=game_info_team.score, + penalty_shots=game_info_team.penalty_shot, + single_shots=game_info_team.single_shots + ) + + def get_team_player_poses() -> Dict[str, Dict[int, Dict[str, List[float]]]]: + """Returns the pose of the team players. + + :return: Dictionary of poses (List of 16 floats to be interpreted as 4x4 matrix), + indexed by team color, player number and frame id + :rtype: Dict[str, Dict[int, Dict[str, List[float]]]] + """ + poses = {} + for team, players in self.data_collection_frame_nodes["teams"].items(): + poses[team] = {} + for number, nodes in players.items(): + poses[team][number] = {} + for frame_id, node in nodes.items(): + poses[team][number][frame_id] = node.getPose() + return poses + + # Get teams + game_info_team_blue = game_info_team_red = None + for team in self.game.state.teams: + if team.team_color == "BLUE": + game_info_team_blue = team + elif team.team_color == "RED": + game_info_team_red = team + if game_info_team_blue is None or game_info_team_red is None: + return + + # Get poses + poses = get_team_player_poses() + players_blue = poses["blue"] + players_red = poses["red"] + + # Team1 is always blue + team1 = create_team(game_info_team_blue, players_blue) + # Team2 is always red + team2 = create_team(game_info_team_red, players_red) + + teams = mi.Teams(team1=team1, team2=team2) + self.data_collector.current_step().teams = teams + + def data_collection_set_game_control_data(self) -> None: + """Sets the game control data for the data collection.""" + gamestate = self.game.state + if gamestate is None: + return + + # Set new game control data object + self.data_collector.current_step().game_control_data = mi.GameControlData( + game_state = mi.GameControlData.GameState(int(gamestate.game_state)), + first_half = gamestate.first_half, + kickoff_team = gamestate.kickoff_team, + secondary_state = mi.GameControlData.SecondaryGameState(int(gamestate.secondary_state)), + secondary_state_info_team = gamestate.secondary_state_info[0], + secondary_state_info_sub_state = gamestate.secondary_state_info[1], + drop_in_team = gamestate.drop_in_team, + drop_in_time = gamestate.drop_in_time, + seconds_remaining = gamestate.seconds_remaining, + secondary_seconds_remaining = gamestate.secondary_seconds_remaining, + ) + def setup(self): # check game type if self.game.type not in ['NORMAL', 'KNOCKOUT', 'PENALTY']: @@ -1977,21 +2305,21 @@ def setup(self): children = self.supervisor.getRoot().getField('children') if (hasattr(self.game, "texture_seed")): random.seed(self.game.texture_seed) - bg = random.choice(['stadium_dry', 'shanghai_riverside', 'ulmer_muenster', 'sunset_jhbcentral', + self.background = random.choice(['stadium_dry', 'shanghai_riverside', 'ulmer_muenster', 'sunset_jhbcentral', 'sepulchral_chapel_rotunda', 'paul_lobe_haus', 'kiara_1_dawn']) - luminosity = random.random() * 0.5 + 0.75 # random value between 0.75 and 1.25 - ball_texture = random.choice(['telstar', 'teamgeist', 'europass', 'jabulani', 'tango']) + self.luminosity = random.random() * 0.5 + 0.75 # random value between 0.75 and 1.25 + self.ball_texture = random.choice(['telstar', 'teamgeist', 'europass', 'jabulani', 'tango']) random.seed() - children.importMFNodeFromString(-1, f'RoboCupBackground {{ texture "{bg}" luminosity {luminosity}}}') - children.importMFNodeFromString(-1, f'RoboCupMainLight {{ texture "{bg}" luminosity {luminosity}}}') - children.importMFNodeFromString(-1, f'RoboCupOffLight {{ texture "{bg}" luminosity {luminosity}}}') - children.importMFNodeFromString(-1, f'RoboCupTopLight {{ texture "{bg}" luminosity {luminosity}}}') + children.importMFNodeFromString(-1, f'RoboCupBackground {{ texture "{self.background}" luminosity {self.luminosity}}}') + children.importMFNodeFromString(-1, f'RoboCupMainLight {{ texture "{self.background}" luminosity {self.luminosity}}}') + children.importMFNodeFromString(-1, f'RoboCupOffLight {{ texture "{self.background}" luminosity {self.luminosity}}}') + children.importMFNodeFromString(-1, f'RoboCupTopLight {{ texture "{self.background}" luminosity {self.luminosity}}}') children.importMFNodeFromString(-1, f'RobocupSoccerField {{ size "{self.game.field_size}" }}') ball_size = 1 if self.game.field_size == 'kid' else 5 # the ball is initially very far away from the field children.importMFNodeFromString(-1, f'DEF BALL RobocupTexturedSoccerBall' - f'{{ translation 100 100 0.5 size {ball_size} texture "{ball_texture}" }}') + f'{{ translation 100 100 0.5 size {ball_size} texture "{self.ball_texture}" }}') self.ball = self.blackboard.supervisor.getFromDef('BALL') self.game.ball_translation = self.blackboard.supervisor.getFromDef('BALL').getField('translation') @@ -2089,6 +2417,8 @@ def setup(self): if hasattr(self.game, 'record_simulation'): try: + # Create the directory if it does not exist + os.makedirs(os.path.dirname(os.path.abspath(self.game.record_simulation)), exist_ok=True) if self.game.record_simulation.endswith(".html"): self.supervisor.animationStartRecording(self.game.record_simulation) elif self.game.record_simulation.endswith(".mp4"): @@ -2101,11 +2431,18 @@ def setup(self): except Exception: self.logger.error(f"Failed to start recording with exception: {traceback.format_exc()}") self.clean_exit() + self.logger.info("Setup complete.") def main_loop(self): + def should_run_data_collection(current_step_count: int) -> bool: + return self.game.data_collection["enabled"] and self.game.data_collection["step_interval"] > 0 and current_step_count % self.game.data_collection["step_interval"] == 0 + previous_real_time = time.time() + step_count: int = 0 while self.supervisor.step(self.time_step) != -1 and not self.game.over: - if hasattr(self.game, 'max_duration') and (time.time() - self.blackboard.start_real_time) > self.game.max_duration: + step_start_time = time.time() # Also gets used for data collection + step_count += 1 + if hasattr(self.game, 'max_duration') and (step_start_time - self.blackboard.start_real_time) > self.game.max_duration: self.logger.info(f'Interrupting game automatically after {self.game.max_duration} seconds') break self.print_status() @@ -2118,6 +2455,20 @@ def main_loop(self): send_play_state_after_penalties = False previous_position = copy.deepcopy(self.game.ball_position) self.game.ball_position = self.game.ball_translation.getSFVec3f() + + # Collect data of step + if should_run_data_collection(step_count): + try: + self.data_collector.create_new_step(self.sim_time.get_sec()) + self.data_collection_set_ball_data() + + if self.game.state is not None: + self.data_collection_set_game_control_data() + self.data_collection_set_team_data() + except Exception: + self.game.data_collection["enabled"] = False # Disable data collection + self.logger.error(f"Failed to collect data: {traceback.format_exc()}") + if self.game.ball_position != previous_position: self.game.ball_last_move = self.sim_time.get_ms() self.update_contacts() # check for collisions with the ground and ball @@ -2403,7 +2754,13 @@ def main_loop(self): self.game_controller_send('STATE:SET') elif self.game.ready_real_time is not None: # initial kick-off (1st, 2nd half, extended periods, penalty shootouts) - if self.game.ready_real_time <= time.time(): + if self.first_step_done and self.game.ready_real_time <= time.time(): + # The first step done check is necessary in case the ready real time has + # already passed before the first step is done. + # This can happen if setting up the game (and spawning robots) takes a lot of time. + # If we send the ready state before the first step is done, the game controller + # will skip the ready state and go directly to the set state. + # This messes up the referee and it is stuck listening for the game controller... :( self.logger.info('Real-time to wait elapsed, moving to READY') self.game.ready_real_time = None self.check_start_position() @@ -2468,7 +2825,18 @@ def main_loop(self): wait_time = min_step_time - step_time_until_now if wait_time > 0: # wait only if the step was completed faster than the minimum required time time.sleep(wait_time) # wait for the remaining time - previous_real_time = time.time() # update the previous real time + + step_end_time = time.time() + + if should_run_data_collection(step_count): + try: + delta = step_end_time - step_start_time + self.data_collector.current_step().delta_real_time = delta + except Exception: + self.logger.error(f"Failure during step time calculation: {traceback.format_exc()}") + + self.first_step_done = True + previous_real_time = time.time() # update the previous real time for the next step # for some reason, the simulation was terminated before the end of the match (may happen during tests) if not self.game.over: @@ -2486,7 +2854,7 @@ def main_loop(self): self.logger.info(f'The winner is the {self.game.state.teams[winner].team_color.lower()} team.') elif self.game.penalty_shootout_count < 20: self.logger.info('This is a draw.') - else: # extended penatly shoutout rules to determine the winner + else: # extended penalty shootout rules to determine the winner count = [0, 0] for i in range(5): if self.game.penalty_shootout_time_to_reach_goal_area[2 * i] is not None: @@ -2584,9 +2952,9 @@ def main_loop(self): else: self.logger.info('Tossing a coin to determine the winner.') if bool(random.getrandbits(1)): - self.logger.info('The winer is the red team.') + self.logger.info('The winner is the red team.') else: - self.logger.info('The winer is the blue team.') + self.logger.info('The winner is the blue team.') if __name__ == '__main__': diff --git a/controllers/referee/referee_config.yaml b/controllers/referee/referee_config.yaml index dd708cc1..5f0a44d5 100644 --- a/controllers/referee/referee_config.yaml +++ b/controllers/referee/referee_config.yaml @@ -22,7 +22,7 @@ END_OF_GAME_TIMEOUT: 5 # Once the game is finished, let the re BALL_IN_PLAY_MOVE: 0.05 # the ball must move 5 cm after interruption or kickoff to be considered in play FOUL_PUSHING_TIME: 1 # 1 second FOUL_PUSHING_PERIOD: 2 # 2 seconds -FOUL_VINCITY_DISTANCE: 2 # 2 meters +FOUL_VICINITY_DISTANCE: 2 # 2 meters FOUL_DISTANCE_THRESHOLD: 0.1 # 0.1 meter FOUL_SPEED_THRESHOLD: 0.2 # 0.2 m/s FOUL_DIRECTION_THRESHOLD: 0.523599 # 30 degrees diff --git a/controllers/referee/requirements.txt b/controllers/referee/requirements.txt deleted file mode 100644 index b552135e..00000000 --- a/controllers/referee/requirements.txt +++ /dev/null @@ -1,5 +0,0 @@ -construct -numpy -transforms3d -scipy -pyyaml diff --git a/controllers/referee/requirements/common.txt b/controllers/referee/requirements/common.txt new file mode 100644 index 00000000..6583791b --- /dev/null +++ b/controllers/referee/requirements/common.txt @@ -0,0 +1,9 @@ +# Requirements common to all environments +construct +dataclasses-json +numpy +pandas +pyarrow +pyyaml +scipy +transforms3d diff --git a/controllers/referee/requirements/dev.txt b/controllers/referee/requirements/dev.txt new file mode 100644 index 00000000..ba68e442 --- /dev/null +++ b/controllers/referee/requirements/dev.txt @@ -0,0 +1,6 @@ +# Requirements necessary for development +pylint = "^2.15.9" +pytest = "^7.2.0" +lark = "^1.1.5" +protobuf +mypy-protobuf diff --git a/controllers/referee/team.py b/controllers/referee/team.py index 966ccb56..61774ece 100644 --- a/controllers/referee/team.py +++ b/controllers/referee/team.py @@ -25,7 +25,7 @@ class Team(SimpleNamespace): @classmethod def from_json(cls, json_path): try: - with open(json_path) as json_file: + with open(json_path, 'r') as json_file: team = json.load(json_file) for field_name in ["name", "players"]: if field_name not in team: diff --git a/worlds/robocup.wbt b/worlds/robocup.wbt index 7571bb20..6c871b4c 100644 --- a/worlds/robocup.wbt +++ b/worlds/robocup.wbt @@ -16,10 +16,10 @@ IMPORTABLE EXTERNPROTO "../protos/robots/utra/BezRobocup/BezRobocup.proto" WorldInfo { info [ - "Description: official soccer simulation for the 2021 Robocup Virtual Humanoid League (kid size)" + "Description: Official soccer simulation for the 2022/2023 RoboCup Humanoid League Virtual Season (kid size)" "Version 0.3" ] - title "Robocup V-HL Kid" + title "RoboCup HLVS Kid" basicTimeStep 8 physicsDisableTime 0.1 physicsDisableLinearThreshold 0.1