diff --git a/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/.gitignore b/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/.gitignore
new file mode 100644
index 000000000..647afd8d4
--- /dev/null
+++ b/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/.gitignore
@@ -0,0 +1,60 @@
+# Python cache and build artifacts
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+*.so
+*.egg-info/
+build/
+dist/
+
+# Virtual environments
+.venv/
+venv/
+env/
+ENV/
+
+# Notebook and editor artifacts
+.ipynb_checkpoints/
+.vscode/
+.idea/
+
+# Test and coverage output
+.pytest_cache/
+.coverage
+.coverage.*
+htmlcov/
+
+# Logs and local environment files
+*.log
+.env
+.env.*
+
+# Model artifacts
+*.pt
+*.pth
+*.onnx
+
+# Data and generated outputs
+data/
+outputs/
+results/
+runs/
+checkpoints/
+temp/
+tmp/
+
+# Media artifacts
+*.mp4
+*.avi
+*.mov
+*.mkv
+*.png
+*.jpg
+*.jpeg
+*.csv
+*.json
+
+# OS files
+.DS_Store
+Thumbs.db
diff --git a/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/README.md b/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/README.md
new file mode 100644
index 000000000..a8e3ec1a2
--- /dev/null
+++ b/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/README.md
@@ -0,0 +1,151 @@
+# Crowd Monitoring Module (Orion Project)
+
+## Overview
+
+This repository contains the Crowd Monitoring module for the Orion project under Redback Operations.
+
+The purpose of this module is to analyse stadium crowd behaviour and density using computer vision and data analytics. The expected outputs include:
+
+- crowd heatmaps
+- density metrics
+- zone-based analytics
+- behaviour insights for integration into the Orion analytics dashboard
+
+## Objectives
+
+- Detect and analyse spectators in stadium footage
+- Estimate crowd density and distribution
+- Generate zone-based crowd analytics
+- Produce crowd heatmaps and visualisations
+- Develop AI-based crowd behaviour analysis
+- Optionally predict future attendance using machine learning models
+
+## Proposed Pipeline
+
+```text
+Video Input
+    |
+    v
+Frame Extraction (OpenCV)
+    |
+    v
+Person Detection (YOLOv8)
+    |
+    v
+Crowd Density Estimation
+    |
+    v
+Zone-based Analysis
+    |
+    v
+Heatmap Generation
+    |
+    v
+Analytics Output (JSON / CSV)
+    |
+    v
+Behaviour Analysis / Prediction
+```
+
+## Tech Stack
+
+- Python
+- YOLOv8 (Ultralytics)
+- OpenCV
+- NumPy
+- Pandas
+
+## 👥 Team Tasks (7 Members)
+
+Each team member owns one task. Follow the README in each task folder for detailed objectives and deliverables.
+
+| # | Task Folder | Team Member | Objective |
+|---|-------------|-------------|-----------|
+| 1 | **video_processing** | Member 1 | Extract frames and prepare video data |
+| 2 | **crowd_detection** | Member 2 | Detect persons using YOLOv8 |
+| 3 | **density_zoning** | Member 3 | Calculate density and zone-based analytics |
+| 4 | **heatmap** | Member 4 | Generate crowd heatmaps |
+| 5 | **analytics_output** | Member 5 | Create reports and output files (JSON/CSV) |
+| 6 | **crowd_behaviour_analytics** | Member 6 | Analyze crowd movement and behavior patterns |
+| 7 | **crowd_allocation_risk_zone** | Member 7 | Assess risk levels and crowd allocation strategy |
+
+**Optional:** `prediction_optional/` - Attendance prediction (if time permits)
+
+---
+
+## Task Guidance
+
+Each task folder contains its own `README.md` with:
+
+- 🎯 Task objective
+- 📥 Expected inputs and outputs
+- 💡 Implementation notes
+- ✅ Suggested deliverables
+
+This keeps the semester plan split into smaller, easier-to-manage work packages.
+
+---
+
+## Project Structure
+
+```text
+2026_T1/
+|-- data/                           # Sample videos and frames
+|-- docs/                           # Documentation and notes
+|-- shared/                         # Common utilities and configs
+|-- requirements.txt                # Dependencies
+|-- README.md                       # This file
+|
+|-- Task Folders (one per member):
+|-- video_processing/               # Task 1: Video extraction & preparation
+|-- crowd_detection/                # Task 2: Person detection (YOLOv8)
+|-- density_zoning/                 # Task 3: Density & zone analysis
+|-- heatmap/                        # Task 4: Heatmap generation
+|-- analytics_output/               # Task 5: Report generation
+|-- crowd_behaviour_analytics/      # Task 6: Behavior analysis
+|-- crowd_allocation_risk_zone/     # Task 7: Risk assessment & allocation
+|
+|-- Optional:
+`-- prediction_optional/            # Optional: Attendance prediction
+```
+
+---
+
+## 🚀 Getting Started
+
+1. **Find your task** in the table above
+2. **Read the README** in your task folder
+3. **Follow the implementation notes**
+4. **Deliver outputs** as specified
+5. **Update your README** with progress
+
+---
+
+## 📋 Integration Points
+
+Tasks run in sequence:
+
+```
+video_processing (Task 1)
+         ↓
+crowd_detection (Task 2)
+         ↓
+density_zoning (Task 3)
+         ↓
+heatmap (Task 4) + analytics_output (Task 5)
+         ↓
+crowd_behaviour_analytics (Task 6)
+crowd_allocation_risk_zone (Task 7)
+         ↓
+         ↓
+Dashboard / Report Integration
+```
+
+---
+
+## 💬 Collaboration
+
+- **Shared utilities:** Use files in `shared/` folder
+- **Input/Output:** Check task README for I/O specifications
+- **Questions:** Document in docs/ folder
+- **Results:** Save outputs to designated location in your task folder
diff --git a/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/analytics_output/README.md b/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/analytics_output/README.md
new file mode 100644
index 000000000..4ce76aeff
--- /dev/null
+++ b/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/analytics_output/README.md
@@ -0,0 +1,36 @@
+# Analytics Output
+
+## Objective
+
+Generate structured outputs that can be consumed by the Orion dashboard or related services.
+
+## Scope
+
+- Export analysis results in JSON and CSV formats
+- Define a clean schema for crowd metrics
+- Prepare data for backend and frontend integration
+
+## Inputs
+
+- Detection results
+- Density and zoning summaries
+- Heatmap metadata if relevant
+
+## Outputs
+
+- JSON files
+- CSV files
+- A documented output structure
+
+## Implementation Notes
+
+- Keep field names stable and descriptive
+- Include timestamps, frame IDs, and zone metrics where useful
+- Design the structure so it can be used before full production data exists
+- Prefer simple schemas first, then extend only if needed
+
+## Suggested Deliverables
+
+- A serializer or export script
+- Example JSON and CSV output
+- A short schema note in this folder or `docs/`
diff --git a/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/crowd_allocation_risk_zone/README.md b/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/crowd_allocation_risk_zone/README.md
new file mode 100644
index 000000000..3eaf00312
--- /dev/null
+++ b/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/crowd_allocation_risk_zone/README.md
@@ -0,0 +1,43 @@
+# Crowd Allocation & Risk Zone Planning
+
+## Objective
+
+Assess crowd safety risk levels across zones and provide recommendations for crowd allocation and management strategies to prevent dangerous situations.
+
+## Scope
+
+- Identify high-risk zones based on crowd density thresholds
+- Assess cumulative risk factors (density, behavior, movement patterns)
+- Create risk zone maps for different crowd levels
+- Suggest crowd allocation strategies to balance load
+- Develop evacuation or crowd control recommendations
+
+## Inputs
+
+- Per-zone density counts from density_zoning task
+- Crowd behaviour analysis from crowd_behaviour_analytics task
+- Zone definitions and capacity data
+- Historical incident or risk data (if available)
+
+## Outputs
+
+- Risk zone classifications (low, medium, high, critical)
+- Risk heatmaps with threshold indicators
+- Crowd allocation recommendations
+- Safety alerts and warnings
+- Evacuation route suggestions (if applicable)
+
+## Implementation Notes
+
+- Define clear density thresholds for each risk level per zone
+- Combine density metrics with behavior flags to assess risk
+- Keep allocation recommendations practical and implementable
+- Focus first on identifying critical zones, then suggest improvements
+- Document risk thresholds and decision logic clearly
+
+## Suggested Deliverables
+
+- Risk zone map visualization
+- Allocation recommendation report (JSON/CSV)
+- Risk threshold configuration file
+- Examples showing critical scenarios and responses
diff --git a/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/crowd_behaviour_analytics/README.md b/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/crowd_behaviour_analytics/README.md
new file mode 100644
index 000000000..2757b9530
--- /dev/null
+++ b/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/crowd_behaviour_analytics/README.md
@@ -0,0 +1,36 @@
+# Crowd Behaviour Analytics
+
+## Objective
+
+Analyse movement patterns in the crowd and detect behaviour that may indicate risk or unusual conditions.
+
+## Scope
+
+- Analyse crowd movement over time
+- Detect sudden crowd movement
+- Detect abnormal behaviour
+- Detect crowd surges
+
+## Inputs
+
+- Sequential detections across frames
+- Optional tracking or motion features
+
+## Outputs
+
+- Behaviour event flags
+- Movement summaries
+- Data that can support alerting or dashboard visualisation
+
+## Implementation Notes
+
+- Start with simple movement heuristics before advanced models
+- Compare position changes across frames
+- Focus first on interpretable signals that are easy to validate
+- Document assumptions clearly because this task can become ambiguous quickly
+
+## Suggested Deliverables
+
+- A prototype behaviour analysis script
+- A few example scenarios or simulated cases
+- A list of event definitions used by the module
diff --git a/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/crowd_detection/README.md b/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/crowd_detection/README.md
new file mode 100644
index 000000000..65e14b5ae
--- /dev/null
+++ b/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/crowd_detection/README.md
@@ -0,0 +1,36 @@
+# Crowd Detection
+
+## Objective
+
+Detect spectators in stadium footage using a person-level detection pipeline.
+
+## Scope
+
+- Run person detection on frames or video
+- Focus on detecting spectators rather than general scene objects
+- Compare results against the previous segmentation-based approach where useful
+- Prepare detection outputs for density and zone analysis
+
+## Inputs
+
+- Extracted video frames
+- Sample stadium footage
+
+## Outputs
+
+- Bounding boxes for detected people
+- Confidence scores
+- Structured detection results for later tasks
+
+## Implementation Notes
+
+- Use YOLOv8 through Ultralytics
+- Start with the `person` class only
+- Save outputs in a simple format such as JSON or CSV
+- Record known failure cases such as occlusion, distance, and low lighting
+
+## Suggested Deliverables
+
+- A detection script or notebook
+- Sample visual output with boxes drawn on frames
+- A saved set of person coordinates or detections
diff --git a/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/density_zoning/README.md b/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/density_zoning/README.md
new file mode 100644
index 000000000..9be04be43
--- /dev/null
+++ b/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/density_zoning/README.md
@@ -0,0 +1,36 @@
+# Density And Zoning
+
+## Objective
+
+Estimate crowd density and distribution across different stadium zones.
+
+## Scope
+
+- Count detected people
+- Divide the frame or stadium view into logical zones
+- Measure per-zone crowd load
+- Normalize density values for comparison
+
+## Inputs
+
+- Person detections from the crowd detection task
+- Zone definitions or a simple grid layout
+
+## Outputs
+
+- Per-zone counts
+- Density values
+- Summary tables for downstream analytics
+
+## Implementation Notes
+
+- Start with a simple grid-based zoning approach
+- Use detected person positions such as bounding-box centers
+- Keep the first version deterministic and easy to inspect
+- Make the zone layout configurable if possible
+
+## Suggested Deliverables
+
+- A script that maps people into zones
+- A table of zone counts and densities
+- Example output using sample coordinates or detections
diff --git a/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/docs/PROJECT_DOCUMENTATION.md b/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/docs/PROJECT_DOCUMENTATION.md
new file mode 100644
index 000000000..8eaf4f203
--- /dev/null
+++ b/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/docs/PROJECT_DOCUMENTATION.md
@@ -0,0 +1,233 @@
+# Crowd Monitoring Project Documentation
+
+## Overview
+
+This document provides a complete overview of the Crowd Monitoring module for the Orion project. It is based on the trimester plan provided in the team guidance document and summarises the project scope, task structure, pipeline, expected outputs, and implementation direction.
+
+The main purpose of this project is to analyse stadium footage and generate crowd analytics that can be integrated into the Orion system. The module focuses on crowd density, crowd distribution, heatmap generation, structured analytics output, and crowd behaviour analysis. An optional extension is attendance prediction using machine learning.
+
+## Project Objective
+
+The objective of the Crowd Monitoring module is to develop a crowd analytics pipeline that can:
+
+- analyse stadium footage
+- detect spectators
+- estimate crowd density and distribution
+- generate heatmaps
+- produce structured analytics outputs
+- support crowd behaviour analysis
+- optionally explore attendance prediction
+
+## High-Level Pipeline
+
+```text
+Video Input
+    |
+    v
+Frame Extraction (OpenCV)
+    |
+    v
+Person Detection (YOLOv8)
+    |
+    v
+Crowd Density Estimation
+    |
+    v
+Zone-based Analysis
+    |
+    v
+Heatmap Generation
+    |
+    v
+Analytics Output (JSON / CSV)
+    |
+    v
+Behaviour Analysis / Optional Prediction
+```
+
+## Core Technology Stack
+
+- Python
+- OpenCV
+- YOLOv8 (Ultralytics)
+- NumPy
+- Pandas
+- Matplotlib
+- Scikit-learn
+
+## Task Breakdown
+
+The project is organised into 7 main tasks.
+
+### 1. Video Processing
+
+#### Purpose
+
+Prepare raw stadium footage for the rest of the pipeline.
+
+#### Main Work
+
+- load video files
+- read and extract frames
+- sample frames if needed
+- collect metadata such as frame count, frame size, and FPS
+
+#### Expected Output
+
+- extracted frames
+- frame metadata
+- a reusable preprocessing script or notebook
+
+
+### 2. Crowd Detection
+
+#### Purpose
+
+Detect spectators in stadium footage at the person level.
+
+#### Main Work
+
+- run YOLOv8 on extracted frames
+- identify people in the scene
+- store detections with coordinates and confidence values
+- visualise sample detections
+
+#### Expected Output
+
+- person detections
+- bounding boxes
+- structured detection data
+
+
+### 3. Density and Zoning
+
+#### Purpose
+
+Convert detections into measurable crowd density and zone-level analytics.
+
+#### Main Work
+
+- count detected people
+- divide the scene into zones or grid regions
+- calculate density per zone
+- normalise density values for comparison
+
+#### Expected Output
+
+- zone counts
+- density summaries
+- tables for further analysis
+
+
+### 4. Heatmap Generation
+
+#### Purpose
+
+Visualise where the crowd is concentrated in the stadium view.
+
+#### Main Work
+
+- generate heatmaps from detections or density values
+- create overlay visualisations on video frames or images
+- export visual examples
+
+#### Expected Output
+
+- heatmap images
+- overlay outputs
+- visual density summaries
+
+
+### 5. Analytics Output
+
+#### Purpose
+
+Create structured outputs for integration with the Orion dashboard and related services.
+
+#### Main Work
+
+- export JSON files
+- export CSV files
+- define output schema
+- keep results suitable for backend and frontend use
+
+#### Expected Output
+
+- analytics JSON
+- analytics CSV
+- schema documentation
+
+
+### 6. Crowd Behaviour Analytics
+
+#### Purpose
+
+Analyse movement patterns in the crowd and identify unusual or risky behaviour.
+
+#### Main Work
+
+- analyse movement across frames
+- detect sudden crowd movement
+- detect abnormal behaviour
+- detect crowd surges
+
+#### Expected Output
+
+- event flags
+- movement summaries
+- behaviour-oriented analytics
+
+### 7. Attendance Prediction (Optional Extension)
+
+#### Purpose
+
+Explore a predictive analytics component if time permits.
+
+#### Main Work
+
+- gather historical match data
+- build a basic machine learning model
+- predict attendance based on features such as teams, venue, ladder position, and round
+
+#### Expected Output
+
+- predicted attendance values
+- a baseline evaluation summary
+
+## Task Dependencies
+
+The tasks are connected in a practical sequence:
+
+1. `video_processing` prepares usable input.
+2. `crowd_detection` produces person-level detections.
+3. `density_zoning` converts detections into measurable crowd metrics.
+4. `heatmap` visualises density and distribution.
+5. `analytics_output` packages the results for integration.
+6. `crowd_behaviour_analytics` extends the pipeline with movement-based insights.
+7. `prediction_optional` is independent from the core video pipeline and should only be attempted if time permits.
+
+## Expected Deliverables
+
+By the end of the trimester, the module should ideally provide:
+
+- a working video-to-analytics pipeline
+- sample processed video or frame outputs
+- person detection results
+- density and zoning metrics
+- crowd heatmaps
+- JSON and CSV analytics outputs
+- prototype crowd behaviour analysis
+- optional attendance prediction work if completed
+
+## Suggested Repository Usage
+
+- Keep reusable helper functions in `shared/`
+- Keep planning notes or extended documentation in `docs/`
+- Keep each task folder focused on one part of the project
+- Add examples, scripts, notebooks, or small reports inside the relevant task folders
+
+## Notes
+
+- The attendance prediction task is optional and should not delay core crowd-monitoring work.
+- The behaviour analytics task can begin with simple heuristics before moving to more advanced methods.
+- The first stable milestone should be a clean pipeline from video input to structured crowd analytics output.
diff --git a/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/heatmap/README.md b/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/heatmap/README.md
new file mode 100644
index 000000000..4b0d6977c
--- /dev/null
+++ b/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/heatmap/README.md
@@ -0,0 +1,34 @@
+# Heatmap Generation
+
+## Objective
+
+Visualise crowd density and distribution using heatmaps.
+
+## Scope
+
+- Generate heatmaps from detected people or density values
+- Show hotspots and sparse regions
+- Save visual outputs for reporting and dashboard use
+
+## Inputs
+
+- Person coordinates or zone density data
+- Background frame or image for optional overlay
+
+## Outputs
+
+- Heatmap images
+- Optional overlay images or video frames
+
+## Implementation Notes
+
+- Start with sample coordinates if real detections are not ready
+- Use a consistent colour scale
+- Keep overlays readable and avoid hiding the underlying frame
+- Save examples suitable for README or presentation use
+
+## Suggested Deliverables
+
+- A heatmap generation script or notebook
+- Example heatmap image
+- Optional frame overlay showing density distribution
diff --git a/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/prediction_optional/README.md b/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/prediction_optional/README.md
new file mode 100644
index 000000000..c872b2c5f
--- /dev/null
+++ b/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/prediction_optional/README.md
@@ -0,0 +1,41 @@
+# Attendance Prediction (Optional)
+
+## Objective
+
+Explore predictive analytics for estimating match attendance if time permits.
+
+## Scope
+
+- Use historical match data
+- Build a simple machine learning model
+- Predict attendance using selected features
+
+## Candidate Features
+
+- teams
+- venue
+- ladder position
+- round
+
+## Inputs
+
+- Historical attendance data
+- Match metadata
+
+## Outputs
+
+- Predicted attendance values
+- A basic evaluation summary
+
+## Implementation Notes
+
+- Treat this as an optional extension, not a core dependency
+- Start with a simple regression baseline
+- Keep data preparation and feature selection documented
+- Do not block the core crowd-analysis pipeline on this task
+
+## Suggested Deliverables
+
+- A baseline prediction notebook or script
+- A cleaned sample dataset
+- Basic evaluation metrics and notes
diff --git a/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/requirements.txt b/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/requirements.txt
new file mode 100644
index 000000000..52ef87b08
--- /dev/null
+++ b/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/requirements.txt
@@ -0,0 +1,8 @@
+numpy
+pandas
+opencv-python
+ultralytics
+matplotlib
+scikit-learn
+scipy
+jupyter
diff --git a/26_T1/afl_player_tracking_and_crowd_monitoring/Notebooks/README b/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/test
similarity index 100%
rename from 26_T1/afl_player_tracking_and_crowd_monitoring/Notebooks/README
rename to 26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/test
diff --git a/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/video_processing/README.md b/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/video_processing/README.md
new file mode 100644
index 000000000..430c193e6
--- /dev/null
+++ b/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/2026_T1/video_processing/README.md
@@ -0,0 +1,36 @@
+# Video Processing
+
+## Objective
+
+Prepare stadium footage so it can be used consistently by downstream crowd analysis tasks.
+
+## Scope
+
+- Load input videos
+- Read frames using OpenCV
+- Sample or extract frames at a usable interval
+- Save processed frames for later tasks if needed
+- Validate that video input quality is sufficient
+
+## Inputs
+
+- Raw stadium video files
+- Optional sample clips for testing
+
+## Outputs
+
+- Extracted frames
+- Basic metadata such as frame count, resolution, and FPS
+
+## Implementation Notes
+
+- Use OpenCV for video loading and frame extraction
+- Keep file naming predictable
+- Start with a small test clip before processing longer videos
+- Store reusable helpers in `shared/` when possible
+
+## Suggested Deliverables
+
+- A script or notebook that extracts frames from a video
+- A short note on frame sampling strategy
+- Example output for one sample video
diff --git a/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/test.txt b/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/test.txt
new file mode 100644
index 000000000..3a0c4778d
--- /dev/null
+++ b/26_T1/afl_player_tracking_and_crowd_monitoring/Crowd_Monitoring/test.txt
@@ -0,0 +1 @@
+tested in branch
\ No newline at end of file
diff --git a/26_T1/afl_player_tracking_and_crowd_monitoring/BoundingBoxes b/26_T1/afl_player_tracking_and_crowd_monitoring/player_tracking_logic/BoundingBoxes
similarity index 100%
rename from 26_T1/afl_player_tracking_and_crowd_monitoring/BoundingBoxes
rename to 26_T1/afl_player_tracking_and_crowd_monitoring/player_tracking_logic/BoundingBoxes
diff --git a/26_T1/afl_player_tracking_and_crowd_monitoring/player_tracking_logic/Notebooks/tracking_heatmaps_distance_metrics.ipynb b/26_T1/afl_player_tracking_and_crowd_monitoring/player_tracking_logic/Notebooks/tracking_heatmaps_distance_metrics.ipynb
new file mode 100644
index 000000000..465de3518
--- /dev/null
+++ b/26_T1/afl_player_tracking_and_crowd_monitoring/player_tracking_logic/Notebooks/tracking_heatmaps_distance_metrics.ipynb
@@ -0,0 +1,1782 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# 🏁 Week 5 Tracking Analysis Of Xuan's Data\n",
+        "\n",
+        "**Goal:** Using tacking data from Xuan and parsed by Appar into a CSV file to plot player paths, frame counts and movement patterns."
+      ],
+      "metadata": {
+        "id": "ahSPVtyMCh8z"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**🎞️ 1.1 Upload CSV Files:**"
+      ],
+      "metadata": {
+        "id": "VIQa72o0SAIG"
+      }
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 73
+        },
+        "id": "IFiLSi7CCdUE",
+        "outputId": "08f00481-00ab-45ce-cc73-23fd29ec8923"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<IPython.core.display.HTML object>"
+            ],
+            "text/html": [
+              "\n",
+              "     <input type=\"file\" id=\"files-31dccf27-7e7d-4401-8899-49ef9a39d55b\" name=\"files[]\" multiple disabled\n",
+              "        style=\"border:none\" />\n",
+              "     <output id=\"result-31dccf27-7e7d-4401-8899-49ef9a39d55b\">\n",
+              "      Upload widget is only available when the cell has been executed in the\n",
+              "      current browser session. Please rerun this cell to enable.\n",
+              "      </output>\n",
+              "      <script>// Copyright 2017 Google LLC\n",
+              "//\n",
+              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
+              "// you may not use this file except in compliance with the License.\n",
+              "// You may obtain a copy of the License at\n",
+              "//\n",
+              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
+              "//\n",
+              "// Unless required by applicable law or agreed to in writing, software\n",
+              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
+              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
+              "// See the License for the specific language governing permissions and\n",
+              "// limitations under the License.\n",
+              "\n",
+              "/**\n",
+              " * @fileoverview Helpers for google.colab Python module.\n",
+              " */\n",
+              "(function(scope) {\n",
+              "function span(text, styleAttributes = {}) {\n",
+              "  const element = document.createElement('span');\n",
+              "  element.textContent = text;\n",
+              "  for (const key of Object.keys(styleAttributes)) {\n",
+              "    element.style[key] = styleAttributes[key];\n",
+              "  }\n",
+              "  return element;\n",
+              "}\n",
+              "\n",
+              "// Max number of bytes which will be uploaded at a time.\n",
+              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
+              "\n",
+              "function _uploadFiles(inputId, outputId) {\n",
+              "  const steps = uploadFilesStep(inputId, outputId);\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  // Cache steps on the outputElement to make it available for the next call\n",
+              "  // to uploadFilesContinue from Python.\n",
+              "  outputElement.steps = steps;\n",
+              "\n",
+              "  return _uploadFilesContinue(outputId);\n",
+              "}\n",
+              "\n",
+              "// This is roughly an async generator (not supported in the browser yet),\n",
+              "// where there are multiple asynchronous steps and the Python side is going\n",
+              "// to poll for completion of each step.\n",
+              "// This uses a Promise to block the python side on completion of each step,\n",
+              "// then passes the result of the previous step as the input to the next step.\n",
+              "function _uploadFilesContinue(outputId) {\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  const steps = outputElement.steps;\n",
+              "\n",
+              "  const next = steps.next(outputElement.lastPromiseValue);\n",
+              "  return Promise.resolve(next.value.promise).then((value) => {\n",
+              "    // Cache the last promise value to make it available to the next\n",
+              "    // step of the generator.\n",
+              "    outputElement.lastPromiseValue = value;\n",
+              "    return next.value.response;\n",
+              "  });\n",
+              "}\n",
+              "\n",
+              "/**\n",
+              " * Generator function which is called between each async step of the upload\n",
+              " * process.\n",
+              " * @param {string} inputId Element ID of the input file picker element.\n",
+              " * @param {string} outputId Element ID of the output display.\n",
+              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
+              " */\n",
+              "function* uploadFilesStep(inputId, outputId) {\n",
+              "  const inputElement = document.getElementById(inputId);\n",
+              "  inputElement.disabled = false;\n",
+              "\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  outputElement.innerHTML = '';\n",
+              "\n",
+              "  const pickedPromise = new Promise((resolve) => {\n",
+              "    inputElement.addEventListener('change', (e) => {\n",
+              "      resolve(e.target.files);\n",
+              "    });\n",
+              "  });\n",
+              "\n",
+              "  const cancel = document.createElement('button');\n",
+              "  inputElement.parentElement.appendChild(cancel);\n",
+              "  cancel.textContent = 'Cancel upload';\n",
+              "  const cancelPromise = new Promise((resolve) => {\n",
+              "    cancel.onclick = () => {\n",
+              "      resolve(null);\n",
+              "    };\n",
+              "  });\n",
+              "\n",
+              "  // Wait for the user to pick the files.\n",
+              "  const files = yield {\n",
+              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
+              "    response: {\n",
+              "      action: 'starting',\n",
+              "    }\n",
+              "  };\n",
+              "\n",
+              "  cancel.remove();\n",
+              "\n",
+              "  // Disable the input element since further picks are not allowed.\n",
+              "  inputElement.disabled = true;\n",
+              "\n",
+              "  if (!files) {\n",
+              "    return {\n",
+              "      response: {\n",
+              "        action: 'complete',\n",
+              "      }\n",
+              "    };\n",
+              "  }\n",
+              "\n",
+              "  for (const file of files) {\n",
+              "    const li = document.createElement('li');\n",
+              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
+              "    li.append(span(\n",
+              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
+              "        `last modified: ${\n",
+              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
+              "                                    'n/a'} - `));\n",
+              "    const percent = span('0% done');\n",
+              "    li.appendChild(percent);\n",
+              "\n",
+              "    outputElement.appendChild(li);\n",
+              "\n",
+              "    const fileDataPromise = new Promise((resolve) => {\n",
+              "      const reader = new FileReader();\n",
+              "      reader.onload = (e) => {\n",
+              "        resolve(e.target.result);\n",
+              "      };\n",
+              "      reader.readAsArrayBuffer(file);\n",
+              "    });\n",
+              "    // Wait for the data to be ready.\n",
+              "    let fileData = yield {\n",
+              "      promise: fileDataPromise,\n",
+              "      response: {\n",
+              "        action: 'continue',\n",
+              "      }\n",
+              "    };\n",
+              "\n",
+              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
+              "    let position = 0;\n",
+              "    do {\n",
+              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
+              "      const chunk = new Uint8Array(fileData, position, length);\n",
+              "      position += length;\n",
+              "\n",
+              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
+              "      yield {\n",
+              "        response: {\n",
+              "          action: 'append',\n",
+              "          file: file.name,\n",
+              "          data: base64,\n",
+              "        },\n",
+              "      };\n",
+              "\n",
+              "      let percentDone = fileData.byteLength === 0 ?\n",
+              "          100 :\n",
+              "          Math.round((position / fileData.byteLength) * 100);\n",
+              "      percent.textContent = `${percentDone}% done`;\n",
+              "\n",
+              "    } while (position < fileData.byteLength);\n",
+              "  }\n",
+              "\n",
+              "  // All done.\n",
+              "  yield {\n",
+              "    response: {\n",
+              "      action: 'complete',\n",
+              "    }\n",
+              "  };\n",
+              "}\n",
+              "\n",
+              "scope.google = scope.google || {};\n",
+              "scope.google.colab = scope.google.colab || {};\n",
+              "scope.google.colab._files = {\n",
+              "  _uploadFiles,\n",
+              "  _uploadFilesContinue,\n",
+              "};\n",
+              "})(self);\n",
+              "</script> "
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Saving tracking.csv to tracking.csv\n"
+          ]
+        }
+      ],
+      "source": [
+        "from google.colab import files\n",
+        "uploaded = files.upload()\n",
+        "filename = next(iter(uploaded))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**📖 1.2 Read CSV file into a dataframe (df)**"
+      ],
+      "metadata": {
+        "id": "5qUmBGz9C7xB"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import pandas as pd\n",
+        "\n",
+        "df = pd.read_csv(filename)\n",
+        "\n",
+        "print(f\"Loaded file: {filename}\")\n",
+        "print()\n",
+        "print(df.head())\n",
+        "print()\n",
+        "print(df.info())"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "KQkExV0UC9c2",
+        "outputId": "e6ee8a12-798d-4bc0-cfd7-a3c24622c6e3"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Loaded file: tracking.csv\n",
+            "\n",
+            "   frame_id  player_id  timestamp_s   x1   y1   x2   y2   cx   cy    w    h  \\\n",
+            "0         1          1         0.00  624  478  841  964  732  721  217  485   \n",
+            "1         1          2         0.00  534  419  772  872  653  645  238  452   \n",
+            "2         2          1         0.04  613  482  807  964  710  723  193  481   \n",
+            "3         2          2         0.04  486  418  744  855  615  636  257  436   \n",
+            "4         3          1         0.08  621  483  788  968  704  725  166  484   \n",
+            "\n",
+            "   confidence  \n",
+            "0        0.77  \n",
+            "1        0.74  \n",
+            "2        0.86  \n",
+            "3        0.84  \n",
+            "4        0.80  \n",
+            "\n",
+            "<class 'pandas.core.frame.DataFrame'>\n",
+            "RangeIndex: 761 entries, 0 to 760\n",
+            "Data columns (total 12 columns):\n",
+            " #   Column       Non-Null Count  Dtype  \n",
+            "---  ------       --------------  -----  \n",
+            " 0   frame_id     761 non-null    int64  \n",
+            " 1   player_id    761 non-null    int64  \n",
+            " 2   timestamp_s  761 non-null    float64\n",
+            " 3   x1           761 non-null    int64  \n",
+            " 4   y1           761 non-null    int64  \n",
+            " 5   x2           761 non-null    int64  \n",
+            " 6   y2           761 non-null    int64  \n",
+            " 7   cx           761 non-null    int64  \n",
+            " 8   cy           761 non-null    int64  \n",
+            " 9   w            761 non-null    int64  \n",
+            " 10  h            761 non-null    int64  \n",
+            " 11  confidence   761 non-null    float64\n",
+            "dtypes: float64(2), int64(10)\n",
+            "memory usage: 71.5 KB\n",
+            "None\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**🔝 Results:**\n",
+        "\n",
+        "- Datasets have loaded **Successfully**.\n",
+        "- All data is either float or int which is **Good**.\n",
+        "- non-null count in each column, **Good** no missing data."
+      ],
+      "metadata": {
+        "id": "RT3vy3DvGEDT"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# **📑 Column Descriptions**\n",
+        "\n",
+        "Each row represents a detected object (usually a player) in a single video frame. The columns mean:\n",
+        "\n",
+        "- **frame_id**: The frame number from the video where the detection occurred.  \n",
+        "- **player_id**: The unique identifier assigned to a player by the tracking algorithm (lets us follow them across frames).  \n",
+        "- **timestamp_s**: The timestamp of the frame in seconds.\n",
+        "- **x1, y1**: The coordinates of the top left corner of the bounding box around the player.\n",
+        "- **x2, y2**: The coordinates of the bottom right corner of the bounding box around the player.\n",
+        "- **cx, cy**: The coordinated of the center of the bounding box. Calculated from x1, y1, x2, y2.  \n",
+        "- **w (width), h (height)**: The size of the bounding box around the player in pixels.  \n",
+        "- **conf**: The models confidence score for the detection (0-1).  "
+      ],
+      "metadata": {
+        "id": "eek7tXxCGJSo"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**❄️ 1.4 Unique Frames per  Player**"
+      ],
+      "metadata": {
+        "id": "FQEosOhNBb20"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "player_counts = (df.groupby('player_id').size().reset_index(name='frame_count').sort_values('player_id'))\n",
+        "print(player_counts)"
+      ],
+      "metadata": {
+        "id": "ECx61gsuDBi2",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "367548be-048a-48c0-d070-e18e4155918e"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "    player_id  frame_count\n",
+            "0           1          185\n",
+            "1           2           28\n",
+            "2           3            1\n",
+            "3           4            1\n",
+            "4           5           69\n",
+            "5          34            7\n",
+            "6          36           36\n",
+            "7          45            1\n",
+            "8          49            4\n",
+            "9          50          132\n",
+            "10         55           25\n",
+            "11         62          110\n",
+            "12         63            4\n",
+            "13         64           29\n",
+            "14         69            8\n",
+            "15         70            8\n",
+            "16         72           10\n",
+            "17         73            4\n",
+            "18         78           20\n",
+            "19         79           56\n",
+            "20         86            8\n",
+            "21         87            6\n",
+            "22         88            8\n",
+            "23         98            1\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**🔝 Results:**\n",
+        "- 24 unique player_id\n",
+        "- player_id appear to be done by geunsy number, hence the jump from 5-34 in player_id\n",
+        "- player_id = 1, recorded the most amount of frame_count with 185\n",
+        "- player_id = 3, 4, 45, 98, recorded the least amount of frame_count with 1"
+      ],
+      "metadata": {
+        "id": "fIW51v_lTHpm"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**🏃‍♂️‍➡️ 1.5 Player movement path**\n",
+        "\n",
+        "Here we filter the data to show the movement of a single player via their `player_id`.\n",
+        "\n",
+        "- Plotting player of choice, path on cx - cy coordinates\n",
+        "- Each dot represents their position on one frame\n",
+        "- Each line is their movement from one frame to their next"
+      ],
+      "metadata": {
+        "id": "rb8pp_0ITpkD"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "def plot_player_path(df):\n",
+        "    # Ask user which player_id to plot\n",
+        "    player_choice = int(input(\"Choose one of the player_id numbers from above to identify movement patterns overtime: \"))\n",
+        "\n",
+        "    p = df[df['player_id'] == player_choice].sort_values(['frame_id', 'timestamp_s'])\n",
+        "\n",
+        "    plt.figure(figsize=(6,6))\n",
+        "    plt.plot(p['cx'], p['cy'], color='green', marker=\"o\", markersize=3, linestyle=\"-\")\n",
+        "    plt.title(f\"Player {player_choice} path\")\n",
+        "    plt.xlabel(\"X Position (pixels)\")\n",
+        "    plt.ylabel(\"Y Position (pixels)\")\n",
+        "    plt.gca().invert_yaxis() # Match video coordinates (y downwards?)\n",
+        "    plt.show()\n",
+        "\n",
+        "plot_player_path(df)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 581
+        },
+        "id": "2iFCJHZNGHm-",
+        "outputId": "b30b619b-b59d-46f8-e356-30372760c3e5"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Choose one of the player_id numbers from above to identify movement patterns overtime: 1\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 600x600 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# 🔥 Week 6 HeatMap Overlays\n",
+        "\n",
+        "**Goal:** Use merged dataset to overlay AFL event data (kick/mark/tackle) on heatmap images. Coordinate closely with Ishita's team for frontend-ready visuals."
+      ],
+      "metadata": {
+        "id": "9d_X01U6mdb-"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**💾 2.1 Install SciPy for Gaussian_filter**\n",
+        "\n",
+        "The **heatmappipline.py** file uses the SciPy package for scientific computing in python, we must download in order to perform here on Google Colab."
+      ],
+      "metadata": {
+        "id": "-QwKeY2-mgPK"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip -q install scipy"
+      ],
+      "metadata": {
+        "id": "FzoQa8jpatR0"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**🏃‍♂️‍➡️ 2.2 Run heatmappipline.py**\n",
+        "\n",
+        "We now upload and run out custom `heatmappipline_xuan.py` script on the 'tracking.csv' dataset.\n",
+        "\n",
+        "This script:\n",
+        "- Reads the player tracking data\n",
+        "- Scales the positions to AFL oval dimensions (165m x 135m)\n",
+        "- Bins the positions into a 2D grid (200 x 150 cells)\n",
+        "- Applies Gaussian smoothing (`sigma = 2.0`) to highlight dense areas\n",
+        "- Outputs per-player heatmaps into the `heatmap_outputs` directory"
+      ],
+      "metadata": {
+        "id": "LZ94lkmcmnWu"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from IPython.display import clear_output\n",
+        "\n",
+        "uploaded = files.upload()\n",
+        "clear_output() # wipe the unnecessary log\n",
+        "hmfile = next(iter(uploaded))\n",
+        "print(f\"Loaded file: {hmfile}\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 73
+        },
+        "id": "zpuVK7auyICf",
+        "outputId": "bd8e2dff-8493-4daa-916a-456ce12efb2c"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Loaded file: heatmappipeline_xuan.py\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "csv_name = \"tracking.csv\"\n",
+        "!python heatmappipeline_xuan.py \\\n",
+        "  --inputs \"{csv_name}:Xuan\" \\\n",
+        "  --out-dir heatmap_outputs \\\n",
+        "  --weight-mode conf \\\n",
+        "  --field-length 165 --field-width 135 \\\n",
+        "  --nx 200 --ny 150 \\\n",
+        "  --sigma 2.0 \\\n",
+        "  --group-by player_id"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Byvmpw0imku_",
+        "outputId": "0d6c408b-b474-4b9a-bda5-e2a0f84f644c"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "DEBUG group-by: player_id\n",
+            "Done. Outputs in: /content/heatmap_outputs\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**💡 2.3 Check Generated Heatmaps**\n",
+        "\n",
+        "Here we scan the output folder (`heatmap_outputs`) to confirm which player heatmaps were successfully created. These are our `player_choices` options for `section 2.4`."
+      ],
+      "metadata": {
+        "id": "p4GT0K4hKN24"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import glob, os, re\n",
+        "\n",
+        "files = glob.glob(\"heatmap_outputs/heatmap_*.png\")\n",
+        "pids = []\n",
+        "for p in files:\n",
+        "    m = re.search(r\"heatmap_(\\d+)\\.png$\", os.path.basename(p))\n",
+        "    if m:  # only keep if the filename matches the pattern\n",
+        "        pids.append(int(m.group(1)))\n",
+        "\n",
+        "pids = sorted(pids)\n",
+        "print(\"Player heatmaps found for IDs:\", pids)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Y-vnNH-pEvAS",
+        "outputId": "5de523a1-d297-4085-aae7-2d0855f70ede"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Player heatmaps found for IDs: [1, 2, 3, 4, 5, 34, 36, 45, 49, 50, 55, 62, 63, 64, 69, 70, 72, 73, 78, 79, 86, 87, 88, 98]\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**🔁 2.4 Choose Player heatmap**\n",
+        "\n",
+        "This function prompts the user to enter a `player_id` and then loads the corresponding pre-generated heatmap image.\n",
+        "\n",
+        "- Shows movement intensity for each player on the AFL oval\n",
+        "\n"
+      ],
+      "metadata": {
+        "id": "4fdNXTc85mMd"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import os, matplotlib.pyplot as plt\n",
+        "import matplotlib.image as mpimg\n",
+        "\n",
+        "def player_heatmap():\n",
+        "  player_choice = input(\"Choose one of the player_id numbers from above to identify their heatmap: \").strip()\n",
+        "\n",
+        "  # Build the expected file path\n",
+        "  filename = f\"heatmap_{player_choice}.png\"\n",
+        "  path = os.path.join(\"heatmap_outputs\", filename)\n",
+        "\n",
+        "  if not os.path.exists(path):\n",
+        "    print(f\"No heatmap found for player {player_choice} at {path}\")\n",
+        "    return\n",
+        "\n",
+        "  img = mpimg.imread(path)\n",
+        "  plt.figure(figsize=(8,6))\n",
+        "  plt.imshow(img)\n",
+        "  plt.axis(\"off\")\n",
+        "  plt.title(f\"Player {player_choice} Heatmap\")\n",
+        "  plt.show()\n",
+        "\n",
+        "player_heatmap()\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 527
+        },
+        "id": "ptMpQR7iriYe",
+        "outputId": "f80441d9-7551-4c40-d9a9-6405fecf92d0"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Choose one of the player_id numbers from above to identify their heatmap: 1\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 800x600 with 1 Axes>"
+            ],
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAHtCAYAAACJT886AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsvXe8ZFWd7v1da+29K57cOUHT0DSCBAmSJEhSDKPOVZGZcdTrHWeujs7c6x3fccwDOo7OiAOijI5gQBREBsk5xwa6Sd3QQOfcp0+usNNa7x97V5063Q10Q3WftL58NtWnTp2qVbuq9n7qF56fMMYYLBaLxWKxWCyTBjnaC7BYLBaLxWKx7FusALRYLBaLxWKZZFgBaLFYLBaLxTLJsALQYrFYLBaLZZJhBaDFYrFYLBbLJMMKQIvFYrFYLJZJhhWAFovFYrFYLJMMKwAtFovFYrFYJhlWAFosFovFYrFMMqwAtFgmMffeey9CCO69997RXorFYrFY9iFWAFosE5ArrrgCIUR9y2azLFy4kM997nNs2bJltJfXNC688ELe//73M336dIQQfOMb39jtv63toyeeeGKXvz/ttNM47LDDmrTSXXPzzTfv0ZotFoulWVgBaLFMYL71rW/xq1/9iksuuYQTTzyRH//4x5xwwgmUy+XRXlpT+MpXvsLixYs56qijRnspb4ibb76Zb37zm6O9DIvFMglxRnsBFotl7/Hud7+bY445BoBPf/rTdHV18e///u9cf/31fOxjHxvl1b0+pVKJQqHwqr9ftWoV+++/P93d3UydOnUfrsxisVjGNzYCaLFMIt75zncCiXB6NR544AE+/OEPM2/ePDKZDHPnzuXv//7vqVQq9dtcfvnlCCFYsmTJTn//7W9/G6UUGzZsqF/32GOP8a53vYu2tjby+TynnnoqDz300Ii/+8Y3voEQgmXLlnH++efT0dHBySef/JrPZ//999+dp91Ufv3rX3P00UeTy+Xo7OzkvPPOY926dSNuszv78BOf+AQ/+tGPAEak6wFWr16NEILvf//7/OhHP+KAAw4gn89z9tlns27dOowx/PM//zNz5swhl8vxJ3/yJ/T09IxYw/XXX8973vMeZs2aRSaTYcGCBfzzP/8zcRyPuF0t1f3kk09y4oknksvlmD9/Pj/5yU/2xu6zWCxjBBsBtFgmEa+88goAXV1dr3qba665hnK5zN/8zd/Q1dXF448/zsUXX8z69eu55pprAPgf/+N/8NnPfpYrr7xyp/TrlVdeyWmnncbs2bMBuPvuu3n3u9/N0Ucfzde//nWklFx++eW8853v5IEHHuC4444b8fcf/vCHOeigg/j2t7+NMaaZT3+X9Pf3093dvdP1YRjudN2FF17IV7/6VT7ykY/w6U9/mm3btnHxxRdzyimnsGTJEtrb24Hd24ef+cxn2LhxI3fccQe/+tWvdrm2K6+8kiAI+Nu//Vt6enr413/9Vz7ykY/wzne+k3vvvZcvfelLvPzyy1x88cV88Ytf5Oc//3n9b6+44gqKxSL/5//8H4rFInfffTdf+9rXGBgY4Hvf+96Ix+nt7eXcc8/lIx/5CB/72Me4+uqr+Zu/+Rs8z+NTn/rUG921FotlLGMsFsuE4/LLLzeAufPOO822bdvMunXrzG9/+1vT1dVlcrmcWb9+vTHGmHvuuccA5p577qn/bblc3un+vvOd7xghhFmzZk39uo997GNm1qxZJo7j+nVPPfWUAczll19ujDFGa20OOuggc8455xit9YjHmD9/vjnrrLPq13396183gPnYxz62x89327ZtBjBf//rXd/tvavvotbZDDz20fvvVq1cbpZS58MILR9zPs88+axzHGXH97u7Dz372s2ZXh+FVq1YZwEydOtX09fXVr//Hf/xHA5gjjjjChGFYv/5jH/uY8TzPVKvV11zDZz7zGZPP50fc7tRTTzWA+bd/+7f6db7vmyOPPNJMmzbNBEGw886zWCzjHpsCtlgmMGeeeSZTp05l7ty5nHfeeRSLRa677rp6dG5X5HK5+r9LpRLd3d2ceOKJGGNGpHw//vGPs3HjRu655576dVdeeSW5XI4//dM/BWDp0qW89NJLnH/++Wzfvp3u7m66u7splUqcccYZ3H///WitRzz+X//1Xzfr6e8WP/rRj7jjjjt22g4//PARt/vDH/6A1pqPfOQj9efR3d3NjBkzOOigg0bsh93dh6/Hhz/8Ydra2uo/v/3tbwfgz//8z3EcZ8T1QRCMSLs3rmFwcJDu7m7e8Y53UC6XeeGFF0Y8juM4fOYzn6n/7Hken/nMZ9i6dStPPvnkbq/XYrGMH2wK2GKZwPzoRz9i4cKFOI7D9OnTOfjgg5Hytb/3rV27lq997Wv88Y9/pLe3d8Tv+vv76/8+66yzmDlzJldeeSVnnHEGWmuuuuoq/uRP/oSWlhYAXnrpJQD+8i//8lUfr7+/n46OjvrP8+fP3+Pn+WY47rjj6o0yjXR0dIxIDb/00ksYYzjooIN2eT+u69b/vbv78PWYN2/eiJ9rYnDu3Lm7vL7xsZ5//nm+8pWvcPfddzMwMPCaa5g1a9ZOzTYLFy4EknrE448/frfXbLFYxgdWAFosE5hXEzevRhzHnHXWWfT09PClL32JRYsWUSgU2LBhA5/4xCdGROuUUpx//vn89Kc/5dJLL+Whhx5i48aN/Pmf/3n9NrXbf+973+PII4/c5WMWi8URPzdGrsYSWmuEENxyyy0opXb6fe157Mk+fD129Tivdb1Jayb7+vo49dRTaW1t5Vvf+hYLFiwgm83y1FNP8aUvfWmP1mCxWCYmVgBaLJY6zz77LCtWrOAXv/gFH//4x+vX33HHHbu8/cc//nH+7d/+jRtuuIFbbrmFqVOncs4559R/v2DBAgBaW1s588wz9+7i9zILFizAGMP8+fPr0bFdsSf7sNb122zuvfdetm/fzh/+8AdOOeWU+vWv1v29cePGnSx3VqxYAYxOp7XFYtn72BpAi8VSpxZZMg3dt8YYfvjDH+7y9ocffjiHH344P/vZz7j22ms577zzRtSmHX300SxYsIDvf//7DA0N7fT327Zta/Iz2Ht86EMfQinFN7/5zZ26k40xbN++HdizfVgTXH19fU1d667WEAQBl1566S5vH0URl1122YjbXnbZZUydOpWjjz66qWuzWCxjAxsBtFgsdRYtWsSCBQv44he/yIYNG2htbeXaa6/dqY6tkY9//ON88YtfBBiR/gWQUvKzn/2Md7/73Rx66KF88pOfZPbs2WzYsIF77rmH1tZWbrjhhje83l/96lesWbOmPtnk/vvv54ILLgDgL/7iL9hvv/3e8H3vyIIFC7jgggv4x3/8R1avXs0HPvABWlpaWLVqFddddx1/9Vd/xRe/+MU92oc1cfX5z3+ec845B6UU55133pte64knnkhHRwd/+Zd/yec//3mEEPzqV796VVudWbNm8d3vfpfVq1ezcOFCfve737F06VL+8z//c0Rto8VimUCMSu+xxWLZq9QsThYvXvyat9uVDcyyZcvMmWeeaYrFopkyZYr5X//rf5mnn356hL1LI5s2bTJKKbNw4cJXfZwlS5aYD33oQ6arq8tkMhmz3377mY985CPmrrvuqt+mZgOzbdu23X6eNQuTXW2Nz2lXvN4+OvXUU0fYwNS49tprzcknn2wKhYIpFApm0aJF5rOf/ax58cUX67fZ3X0YRZH527/9WzN16lQjhKhbwtRsYL73ve+NeOza63XNNde87nN56KGHzPHHH29yuZyZNWuW+Yd/+Adz22237bRvas/ziSeeMCeccILJZrNmv/32M5dccslr7j+LxTK+EcbsA6dVi8UyYenu7mbmzJl87Wtf46tf/epoL8eyh5x22ml0d3fz3HPPjfZSLBbLPsTWAFosljfFFVdcQRzH/MVf/MVoL8VisVgsu4mtAbRYLG+Iu+++m2XLlnHhhRfygQ98wHaLWiwWyzjCCkCLxfKG+Na3vsXDDz/MSSedxMUXXzzay7FYLBbLHmBrAC0Wi8VisVgmGbYG0GKxWCwWi2WSYQWgxWKxWCwWyyTDCkCLxWKxWCyWSYYVgBaLxWKxWCyTDCsALRaLxWKxWCYZVgBaLBaLxWKxTDKsALRYLBaLxWKZZFgBaLFYLBaLxTLJsALQYrFYLBaLZZJhBaDFYrFYLBbLJMMKQIvFYrFYLJZJhhWAFovFYrFYLJMMKwAtFovFYrFYJhlWAFosFovFYrFMMqwAtFgsFovFYplkWAFosVgsFovFMsmwAtBisVgsFotlkmEFoMVisVgsFsskwwpAi8VisVgslkmGFYAWi8VisVgskwwrAC0Wi8VisVgmGVYAWiwWi8VisUwyrAC0WCwWi8VimWQ4o70Ai8Uy+hhjqA5VicIYBIjkfyhHJZurkCK5DtOkBxWNC2jifRrQWhNHmjiKiaMYDJjkfzieQ7aQQQjxundnsVjGF+vWrWPp0iVNvlfBcccdx/Tp05t8v6OLFYAWyyTDmJ3VlsHw+K1LGdg+SEtHgZbOIi0dRXItWTL5DNlCBsd10ltSF2xaa3Scbnr4MgpjojBKBFj6+zjWGK0x2mCMId+aZ/b8GWxYuYnyYAWEQEqBlBKpkk0piXIdnJoQTa9vvI2UaSJD1DSlIAoj/LJPdcinPFhhqK/EYG+JwZ4h2qa28I4PHb/L/WBFocUyvnnggftY/uTXOPzQQtPu85HFQ7juj3nXu9610+92PI40HkNe7XeN14/mMccKQItlgvFqAs+Y4U0bPfJSaw5/5yHEQYxfCaiUqlSGKmxf3ctQ/1AioPqHKPWXKA2UKQ0mm1/28asBQTXArwaEfpgIvwZRaLTBaINOhR8mEZFHnHgon//Xv+KSf/wZzz32ApAcDIUUyPRSNAhCJSWO5+BlPLysi5f1yGQ9svks+ZYc+ZY8xdY8xfYixdYCxbYCLe1FCm152ma0MmPBNDI5D+UphqpDSCERQux0Wd/Y+cBsBaLFMvY58bgWzj69o2n3F4aGXaUpjDE8/vjjXHfddbS2tvJXf/VXdHV11Y8Tzz33HFdccQXFYpGvfvWrOE4iuYIg4MILL+Soo47igx/8YNPWuadYAWixjEN2KfJ2EHa1f0dxRBiHVPwKA5UB+kp9bBvYxtb+rWzt28rWga1sH9iOerBA+IqhUqoSpKIuiuK6aGxamjYlDCOMMYRBRFANmnvngrqQc1yVikaPXCGLd5AgOrFEV0sX09qnMb1tOlPbpjK1dSrthXZa863kvByucnGUUxeHOwrFnR7SikOLZUxgMGh0U+8Pdo7cDQ4OctFFF/Gtb32LJ598kssuu4wvf/nL9dtMnTqVP/mTP+HHP/5x/W+NMdx88828/PLLtLW1NW2NbwQrAC2WcUD94NEQydM6TbsaTRRGBH7AYP8Qfb39bOzZxIbtG1i3fR2bejaxtX8L2wd7KFWHqAQVIh2jtaZR1U1dMo9cd3GUnmGTMck+MxiCWBNUQ+gvAVAeHKTbrBu+bSrqHKnIeTmKuSKdxS6mtU1jVucs5k6Zy+zOWczsnEl7Rzst7UW8jIvjOIkwlMm2Y+TQCkKLZXQw6X/NQhvNDTfcwMsvv8LMmTP54Ac/iBCCTZs2USgUWLBgAblcjhtuuIE4juuRvhkzZhDH8XCZCrB27VoWL17Me9/7XjZv3ty0Nb4RrAC0WMYQjd8w65E8rYlNItiCKKDsl+nt7aNn+QAbV21i/Sub2LRmM1vXd9PfM0B5sEIUh0n6teG+JS3pf7tG6MkhWHLbisy5c9Fr3qaXgF7W8yLrETyOlApHORRacrR1tTJ19lRm7jeNuQfOZtb8GXQsaqWjo51CtoCrXJRUiTBsiBzWsMLQYtm7JBHA5glAI2DRokUcf/zxFIvF+me4Ju6EECilkmPuDtmZxp+jKOLHP/4x55xzDqtWrWJwcBDf98lkMk1b655gBaDFMkrsSuzFaWQujEOqQZXtQ9tZv309KzevZMXGFazcspJNPZsor/XpumMeOnz1NIdA7qKKzSIQeyx2jTaEUUifH9LXPcCaF9fXfyddyfaz15Kfm2FW1ywOmH4AC2ctZP70+cztmktnSyc5N4ejHKSUiTi0otBi2Ws0M/pX46CDDuKYY44Zcd3UqVMZGBigv7+fl19+mVmzZiGlZNOmTUybNg0pZV0UxnFSTiOE4KabbuKll15icHCQ8847j4MPPrjp690drAC0WPYBI8Qept4xG2tNHEVUylV6tvWxfuUGVqxZwQsbXmTllpVs6dtMqVoijKMR9+cNZojDeJeNCpZ9SxzFxGsFPT2D9PAiz/EicAuucihmi0xvn8786QewaPbBHLz/wcyZP4uOae3kctkkjawa0shYUWixNIO9IQJ3pKuri/e973185StfIY5jvvCFL+D7PhdeeCEXXnghGzZs4KKLLmLNmjV861vf4ktf+hLf/va3AbjttttYt24dCxcu3OvrfDWsALRY9gKNgq+extUxsY6phlV6BnvY+MIWVj2+jpefWcnal9bTvbGHSqmapm6Tv8/SSZbO0Xoalt3BQNezs171130ELOEFlvIiUklyhSxTZnYxb+EcFh6xgLknT2fO/rPpbOkk62ZRUo1IIdewgtBi2T0MoHfRKPdm7m9XSCk5//zz+cAHPoDjOHieB8C//uu/ksvlKBQKfP/73weSz2+hUKh/js844wy01tYGxmIZ7+xK8EU6IoojSn6JTT2beGH9CyxZtYTn1z3P2m1ryTzURmHFrq0KbGRv/LAnr5WOdWKjM1BmzYvreOCGR9j2jjWogwz7TdmPw+YdxpHzj+Tg2Qczq3MW+UweRzk40rGC0GLZTTSmiT3Arx1NrAm7RvL5PACO49Da2rrLv3Ndt3kLfINYAWixvAF2rN+LdVwXfOWBCptXb2XF06/w9HPP8Py6ZWzq2Ug5KDf8XQa1zRudxVvGDAZDdlUL4XafNWxmDZu5WdxF3sszq3MWh847lCMOeysHHb6AGfOnkW/J1ZtMlFS2jtBi2QWJa9/ejwCOd6wAtFh2k0YrllqEL45jSn6J9d3reWbNMzz+0uNsvGk75cdi/KpfP3JkaCXDrr8JWiYvAkHL+l2n+LczxP08xv3iMTK5DPnjFbPPncKxBx7L4fsfzpyuORQyBZRS9QihtaCxWKDZFYD7op5wNLAC0GJ5FXZM68Y6Jooj/NBna/9Wnl/7PI+seISnXnmKdd3rKPtJhG/Kujm0V6aN4sotEwoDftlny7qtLH70Qa5/7HrymTzzps7j6AOO5u0L386h8w5lett0PNfDUU6907iGFYSWyYSNAO4eVgBaLA00ir5a00YYhwyWB9mwfDPPPricJx9byor1L9JX6iPWSaVJC9Pr/nqZvtworNwy0clvbGVG+YD6z7343MnD3CMfpb3QwaK5B/O244/krScdwuxDZlDMFUeki2tYMWiZ6Bhoqg/gRMUKQIuF4akRsY6J45ggCuge7ObZNc/ywLIHeGLFE5hr8rBl+ESasyldyz7EK2XxStld/s4n5ukXlvH0HcswMyPkn1Y57uBjOfmQkzlsv8OY0jIFz/HqXoQCYYWgZcLS3DkgNgVssUwoGucy1lO7QcDmnk0sfmkx9z5/H0+vWsq2gW5iHYEWzPEXkiE/yiu3WF4bv+qzYf3LvLzxJX5339VMbZ3KUQccyamHnsYxBx7DjM4ZZLw0VayUrRu0TDiM2Tc2MOMdKwAtk4bGJo44rok+ny0ru1n64LM8fudTLF+epHa10Ti0M5N2AIQBpzQ643oslj3BG8gx966DMQ167llW8bxYQ0fhehYdcjDHn3UMR5x8GNPmd5HJZHCkFYOWiYNucsyumWJyLGEFoGXCUxN+tXo+P/RZ172Oh194mPsee4C+ywNKPZX61zwXK/Qs4xcZS7zBXdehDvVXeGLjUp64eymFrhwdn/Q49e2ncOKiE5nTNYeMm6nXDYIVgpbxy8SUbM3FCkDLhKRR9EVxRBAEbN26jUeXP8YdS29n6aql9JX7UWWX2f0HIo16nXu0WCYQBgb7hnjhqZd4aPlDtBXaOWr+kZx1xNkcf8jbmTp9Kp7r1juKwYpBy/hiotbtNRMrAC0Thpro00YTxRFhFNIz1MOyB17ioT88xjOPLqO3rxdtNC3MpIWZCCMQkXyde7ZYJh4iksy+7yCMSD43L7OZleLXXNNxE0eccBgnfuhYDjnpIDqLnbhOIgZr1jJWDFrGMjrdmnl/ExErAC3jmh3r+sI4pFQt8fy657n1qVu577n74L/zeJuT5g2BRGEFn8UiEIho58h375Z+7v3vh7jtsduRH6hy2ltP411HvYtD5hxCIVtIxKAcPnVYMWgZa2hANzEAOFFjiVYAWsYlI6J9UUTgh2xeu4VH7l7M7Y/cwQsbllMNk0kcrYMtr3NvFotlR8SAw8D9Pn984DZud+/jkDmLOPuEsznhnccyfe40vIyL4zhIbFTQMrYwprlROysALZZRptGkOYojwjikv9zPM88/y8M/fYol9z9Lf88AGCjQReE17stisbw2XilD1/Oz6j+vXbKVn934a37f9UeOOvVwTvj0URzxlsNpzbfiqiRFXMOKQctEwgpAi2WU2LG2r9bFe/vS27npyZtYt2wj028/AGHsScdi2asY6Ose4O7r7ueq0hXMe8sc3nvMeznriLPqXcSOslFBy+himLiirZlYAWgZs+xo3zJUGeL555dz3y8f4aElD7N9qAdjDK3BVPtpt1j2JVrQumQa25+r8Ktrfs9Nxbs56aiTOP0TJ/KWtyxKagWtnYxllDA0twbQNoFYLPuImvCL4igZyTbQzb3P38sfHv0DKx9eS+d9swFBMTVptlgs+xaBIL9leBSij+au5ffz+01XseD4/fjQ8R/i1ENPZUrr8Ag6sELQsm9IuoCb+F6boAEGKwAtYwZjDMaY1Kw5YO2Wtdyw+AZufOIG1nWvQ2tN3m/DQDM/2haLpUn4vs8TLz7BUy89xbwp83jfse/nvce8l3nT59bTw0LYOcSWvYxprmaboPrPCkDL6NJY3xdGIRW/ysolq7ntqnt46L5H6BnswZBlFgcBIENr2GyxjFWmLJ2DdmMAIuC/r7qd+1uf5ORTT+Bd57+T+UfMI5vN4irXegpa9hoG0WQBODHfo1YAWkaFRuEXRAFD1SGeePkJrr7rGtZf0kvQGwHgseuRVhaLZWwhELjlnccoDvWXufXXd3H3zfcx93OdfOSdH+aYA4+hkC3gOZ5tGLE0naQJpHnvJxsBtFiawIjGjihkYGCQh55+iN88cBVLVy0lLsfMLi1E2bemxTKhKJcq3PPovTzwzAMcdcBRnH/K+Zx4+Im0tBRxHdswYmkeGkHcRFcIGwG0WN4EjcIviAJ6h3q5b/ED3PPdR3lp2StEccQMFoCxaV6LZSKifIfZ9ywEARsZ4KIf/4ybD72H0790PKceewrthXY8x7NC0PKmabYNjJmgIUArAC17lR2FX89QD7cvvZ3f3P8bVr2whllLFyJjaSN+FssERyBQ4fDn3ADLl6zgritu4oBH9ufPTvkzzjziTDqLnVYIWt40NgX8+tizrmWvsKPw6+vr45777uc39/2GFRtXoI3GKWUm7ifLYrG8PkbgbPdYuXQNFz7zXa6Z+Qf+7LQ/4/RTT6GtrY2Mk0FKWyNo2TNsE8juYQWgpamMaO4IA3pLvdy+9HZ+//vrGPqtQceamRzY8AejtFCLxTLqCC2Y/tj8+s+DaP7zqiu56s+u4sMf+hBnHXEW7cV22yxi2SOa7QM4UU9TVgBamoYxpt7VO1Ae4O5n7uaKe65g+frleJtzzIoOQkzQb1IWi2XPEYidzq461ixb8wJf+c1TXPXAVXzinZ/g9LeeTmuuFddxkUgrAi2viUGgbRPI62IFoOVNUzNwDuKAocoQi594kt/89mqWrlxCFEcUaMcdzI72Mi0Wy3jAQGFTG+FgltUvb+CCB/6Vm+ffwcc+9hGOPeZoitkirnKtobTlVTHWCHq3sALQ8oappXvDKKQclFmycgk/u+NnPHv7i3Q8PJNOZo/yCi0Wy3hDIOh4ccaI61Y/tpl/WP+PHHH2W/j0WZ/myP2PJOflcB03+RsrBC0jEBM2atdMrAC07DGNs3qrQZWXNrzM5Xf9nNuW3k7JL9ESdI7yCi0Wy0TCAEEQcPfT9/D4C49zzlHv4pNnfJKDZh9YHzEHVghaEppuAzNBxaQVgJY9whhDrGP80GdT7yb+eOXN3HH5/fQO9tLJHDoBGVgfP4vF0lw6n5tJ+4ppADx+83O8fPGFnP0/T+V9H3s3Mztm1juGrQi0aATayKbdn2liPeFYwgpAy25Rr/OLAvpKfdz4xI38/K6fM3hfQOe6mWTIj/YSLRbLBKU+Zq48fF2pr8p//f5yrtl6Ff/zjP/JucecS3s+6Ri29YGTG2OE7QLeDawAtLwm9Tq/OKRSqbD4+Se49JZLWbJyCbGOaY+mjfIKLRbLpCUUrFu7nn/+xQXc/OAt/M27/4Zj3nI0uVwOV9n6wMmKaXINoE0BWyYVjUbO1bDKyi0r+f3FN/DIb5+gUq0ym4UAiLh5YXaLxWLZE9pfmkbbyikAbGaIf/nZJRzz14fyZx//KPOnzSfjZuxEkUlIUgNoBeDrYQWgZSca0709Qz1c+8i1XH7X5Zg7s7QOdNmxbRaLZUwgYwXxcM2xHwT84f7ruL33Zj515qf40Ns/REexA8/xACsCJwvNnwQyMbFnckudxnRvtVrlqaeW8qM/XsrSVUuJdUynXxjlFVosFstr4w559K4c4KKfXcx9dz/I597/WY486nBy2ZztFp4E1DqAYxsBfF2sALQAw1M8/NBn/fb1/O6nf+DBnzxBpVwdHt02Ub8GWSyWCUPn87PofD7592YG+faVP+Qdnz2Wj3zqg8zunE3GzdhpIhOc5tcATkysAJzk1KJ+QRQwVB3itiW38aNbfsTAfT6dpZl2dJvFYhk37Gq0XGWoylW3/I5bhv7I5879HGcfeXYyTcSaSE9Ymu8DODGxAnASY4xBa40f+Kx5aR3/+ev/4s6n7yKMAgq9baO9PIvFYmkKXk+O7sf7+fZT32PxkUv5X3/+KeYdOIeMZ70DJyLNjgAyQQMhVgBOQhqjfv3lfu76/f38/l9voHtTD53MGuXVWSwWS3NpWd9By/oOAJ545HnWXP9tPvyl9/HOPz2F1lyrbRKZYJhmG0FbAWiZCNSiftWwyoqNK/jBH3/Asl+sorCpfbSXZrFYLPuEbRu3871LfsAtgzfwd+/7Ow6aeRBZL2trAycIhuYaQWs7CcQynmmM+g1UBrjxnpv4zcXXsrV3C7ltraO8OovFYtm3OFszLPnFcv7hhq/yZ1/4MO855Vxac622NnAC0GwfwImKFYCTgMYO31c2v8IP/vgDHrz/EWYsPoB2M320l2exWCz7nEx/nkx/norUXPirb/PAmvv5+/f9PfOnz7edwuMc6wO4e1gBOIFp9PUrVUvc+tStXHTDRazfvp5MnBvl1VksFsvYIIwibnnyFp5b8xx//76/5+yjkk5h6xs4PjGmuWnbiRpNtAJwgmKMwWDwQ5+tm7dx5fd/z8133ooOs8ziQGQoYYLWNVgsFsvuIrRg6lNzMY4mBi6+8b9YdfYmzv+/f8rU6VPIuBkwVgSOJ6wP4O5hBeAExBhDrGMqQYXHVjzGxT/6MX2/C1AmQ57MaC/PYrFYxgwCQW57ccR1t1x+F4/4D/D5v/nfHHfQceS8HEoqKwLHCbrZTSATNALYvD5py6gzYobvYA8/u+W/+PyPv8Dy1S/U08EWi8VieW2MMSxftZzP//gLXH7b5fQM9RBGYf0Yaxn7GCOatk3UbJmNAE4Qagemalhl1ZZVfO/a7/PCZWto75+NiKzOt1gslj1h6lPzME9rfnPvdSz966V88UNfZP9p+5N1s4BNCY9ljGl2CnhivtZWAE4Aainfsl/mvufv41+u/RfWbF7DnKFFuCWb8rVYLJY9QSBwqokdjO/E3L70dlZsWcGX//TLnHzIyeQzeZsSHsMkPoDWCPr1sAJwHFPv8o1CBvoGufrqa/mvW3/OUHWIou5AhmqUV2ixWCzjGxkqims72La+j689+898+tz/yf/48AdpbWuxnoFjFEOaum3a/U1MrAAcpzR2+a7bvI7L/7/f8ugtT1KIp1Bgymgvz2KxWCYETtlj2uL96j//7sEbWPfwZj757fOYPX227RIeg+h0axYTtezTFoeNQ2rGzuVqmUdffJT//aPP8sCdD6NjjdjhP4vFYrG8cXY8pupYc+/tD/K/L/0sj694nLJfRhttm0PGEqY2DaR520TECsBxhjGGKI4YKA9wwx9u4Zuf/xe23TGACO1LabFYLPsCGUq23NbH1z//HW7679sYKA8Q6ciKwDGCRqCNbNr2WjWAxhjiOEbrnb8EGGPQWhPHcf13r3X7fY1NAY8TGmf5bh/czqW3XMptl9xL/vkO2pk2yquzWCyWyYOMFO0vT8MA3/d/wPPmaf7mXX9DZ7ETz/EAmxIeTQyvLdr2nF3flzGG++67j+uvv55CocBnP/tZZsyYUX/tlyxZwk9/+lOKxSLf+c53UEpx3XXX8fDDD6O15gMf+ADveMc7Ru29YsNG44BavV/N4uUffvEP/OKeX+CHwWgvzWKxWCY11dDn8rsu5x9+8Q+s3rqaalgFGPXozmSnNg2keduw3Vrtte3v7+cnP/kJf//3f88xxxzDZZddNmIN++23H5/85CdZv359/W+OOuoovvKVr/DXf/3X/Md//AfVanVf75o6NgI4xqm92SpBhSWrlvCtn/8zPTeWmR7PxxvMjvbyLBaLZVLTsq6DTF+OZQ+t5gub/o6vffKrHLH/EeS8ZN66jQTue2qCrVlobbjm6mt4eunTzJkzh/PPPx8hBJs3b6alpYU5c+aglOLqq68miiJcN+kO7+rqolqtImUSaxNCMH/+fIwxvPLKK7S1teE4oyfDrAAcwzT6+93x9B1ccM0F9K7vZ+7mRcjYWrxYLBbLaOOWMrilDNqJWb56OX/707/lnz78T5x1xFnkvTxSSisC9zHGgG7m9A4hOOGE4zn55HeQy+Xqr2djlHd3X2NjDCtXruSSSy7h//2//2cFoGVnas0eg+UhfnPPlVxy8yUMVUu4cYZXq0ewWCwWyyhhQMaSLd1b+fLl/8SW927lvNM+SjFfxJGOFYH7EN10I2jJ3LlzOeSQQ0ZcP23aNAYHB+np6WH58uXMnTsXKSWrV69mzpw5SCkJwxCtNWEY4jgOK1eu5Fvf+hZf+MIXWLhwYdPW+EawNYBjEGMMYRzS29vHL/75t1zzt7fQccNc5t6xiJkPHYCI7YHEYrFYxhIilsx8cAFz71hExw1z+O3nbuCXF1xNb28fYRzamsB9SL1mr4nbrujs7OSjH/0o3/jGN7j++uv5zGc+QxAEXHTRRZTLZZYvX84FF1zApk2b+OY3v0lfXx+/+MUvGBwc5De/+Q3f+973bA2gZRhjDEEUsLFnI/922UU897NVEEs8bL2fxWKxjFUEArc8cvTmdf95E6+0vMD//au/Y0bHDDzHs5HAfcS+mAQihOADH/gA5557LlLKejr3u9/9Lp7nsWjRIi6++OL6bTOZDF/5yleI43jEdaOFFYBjhNq3w2pYZc26tXz9F1/n6UefY1q8vzV0tlgslnGI1prbHryDbeFWvvmXX2fenHnJ5BBsc8jexJjmNoG8lqXMrkRc7WelFLlcbsTvPM9r4sreHDYFPAaoz/SNQzZt38QP/+9lbPzRIFMbxg9ZLBaLZZxhYNpj+7Hhkj4u+uJlbOrZRBiHya9sSnivkYyCk03bmuspOHawEcBRptHmZenqpTz6wqMccfJhFESR5U+sYKi/NNpLtFgsFssbQCBoaSnylmMOZsFJ+3HdY9dxwqITOHz/w8m51iZmb2EQ6CaKtokq1a0AHEVqM30rfoX7n3iAC37yHfpL/Rzjn8DRh7+NRW87iOVPrmD5EysoDZRHe7kWi8Vi2U0KrXnecuzBLDp6IeWBMg/f+RhPPvAo17Zczz997kuccvgp5DI5JNYmpvkImuuWMTFfHysAR4ma+CtXy9z45I1c9G8/InN3O120spr1bFi8hf0PmccRJx3GorcdxHOPvcALT75EtTx6HUMWi8VieW1yhSyLjl7IoccdTLXk88gtj7PmxXUEQUgXc9GO5sveV/jyp/4/3v22d5PP5K0IbDK16R3NvL+JiBWAo0BtQPSQP8S1j1zLd//wXRhymU57veEjDCJeenola15YxwGH7c+RqRBc+uCzvPLsKsIgGuVnYbFYLJYarudy4OHzOfLkw9Da8MTdS3nl+dWEflLzVzu2C6B3qJevXfU1KkGFD779gxSyBSsCm4gGdBPztjYFbGkKtekeQ9Uhrrrnt/zqW9fQ0j8NVdl1Z1Dgh7zw5EusXr6WRW87iGNOP4pDjjmYJ+9ZyvqXN6K13sfPwGKxWCw1pJLMPXAWR592JPlijmcfXcYLT72MX/F3eXsRS6Y9OQ+jNJe88J9U/1+V804+j0K2gJLKisCm0OQawGZOFRlDWAG4D2kUf1fcfQWXXP8jpq2bT6HU/rp/Wy37LH3wOV5+dhVHnHQo7/zTd7Bx1SaeuOdperb07v3FWywWi2UEXTM6OPr0I5m1/wxWLH2ZZx5e9rqNe8II8ltbARh0t/O9//4eQRTwF6f9BcVs0YrAJpCYN9smkNfDCsB9RE38DVYG+fmdP+fSGy8lqEZ7/M4a6i/x8C2P8+LSVzjm9CN53yfPYdniF3n2kWVUy7v+xmmxWCyW5pEtZDn8hLdwyDEL2bx2KzdccRvbN/fsuVIwgmq5yg//+4dEccQn3vkJWnItVgS+SWqTQJp3fxMTKwD3AY3i76d3/JSfX/ULpj48H6EFTsV9A/cH3Ru3c8dv72G/RfM49p1HMv+Q/Vh811OsWbEeHdu0sMVisTQbqST7HzyXY898G0Yb7v/jI6x5cd0bPubmN7Ux985DMMJw2eDP0EbzqTM+ZUXgm8SYZqdtJ+brYAXgXmZH8ffjW3+M9F28wSziTb5B41iz8vnVbFy1icNPPJRT/+Qk1r2ygcV3LWGgZ7BJz8Dy5tjVazxRv09aLBOXtq5Wjj3jKOYcMJPnHn+B5x5d/qazLipSqEGFEYagGnDJzZcAWBH4JjEItGnenAtbA2jZYxrF33/d+V/853//FO0b3KrbVA1QLfs8fudTrFq2hreffQx/8ql388S9S1mx9BXiKG7eA1lehx0PEq920BDs/AawotBiGYs4rmLhkQdy9GlH0LO1jxt/cTvdm3qa/zhVF78/5Md/uAwhBJ8641O2JvANok1zm0CaeV9jCSsA9xI1n7+h6hBX3HMFl958KV0PzyWzvYDYS+f6bRu3c+uVd7HobQdx7DuPYr+D5/LobU/Q192/dx7QkpKajgp2cfkqmPR/9ctGUWjFoMUyFuiY2sbx5xzLlJmdPHXfM7y45CWicC98qTYw/bH9MQKqU4a4JHsJrnL5+Gkfp5grWouYPaa5PoAT9ZBsBeBeoFH8/eb+33DxTRfjhz4ikqhI7dXHjsKI5x5bzoaVGzn+nGN43yfPYfHdS3hp6SvEtjawydSEX21LxzqJXYnABoHXKP6MwaSXyXWm4WAzQY86FssYRzmKg486kGNOP5KtG7q54fLb9uoXaYFAxMm5QUYSP/S56IaL8ByPj73jY9YncA9Jj6ZNvL+Jud+tAGwyjRM+rn3kWv7jmosR21xyxkWGe1f8NdK7rZ/bf3svhxy9kOPOfBtzFszi0dufYKjPzhZuDo3CTyQHZln7txwhCkeGAoeFXyL+NMKkEUBjMLpBCNZub7FY9hktHUVOOOcYZuw3nSfvWcoLT728T0tpZKjIbStigB9cfRFZL8uHjv8QhUwBsLODdweDaGrd3kQ9ClsB2ESMMRhjqPgVbnrypmTCxzqX2Y8tGJX1xFHMc48tZ9OazZx07tt5/yffxUO3PM7aF9djzER9S+9t0qhfTexJCTIVfXJ4E3KkQKxjzLD40wZhdGJZrzVGa4RMfjbGJNfXIoMT9hBksYwNhBDst2guJ777OAZ7B7nxittHxWPV688x676DANh8wiq+c+13yHt53n30u8l7+fpaLa9Ocvi0AvD1sAKwSRhjMBgqQYV7n7uXC665gKHqEEU6gOExQKPB9s293HrlXRxx0mGc/sGTWf7ECpbc/wxBOqLIsrs0RPxS4YdUCCWHL5UaIQRrQrFOTQBqjdAGYg06TsRfHEOsMUInwlCkEUGjh9PGFoul6XhZj7edengyd/3R5Tz98PP1EW77mtq5wqSf98HKIN+8+pvks3lOO/Q0cpkcGCsCX4um+wDaLmDLq1GLplWDKo+/9Dhfu/JrRMsEbeFUMr35UV5dQuCHPHHPUjav28rJ73k70+dO5f4bHqFvm20Q2T2G6/1ELcqXCj6hFDhOIv4clVwqiVE7pIIbUr8i1qB1IgDjGBHFICVGxsnv4hhDnPyZlskfG40VgRZLc+mY1s4p7zuBXDHHnVffx/qVG8fMxyy/uRWn6hK6EV+78uv84H/+O8ceeCxZLzvaSxvTGJrbuTtG3g5NxwrAJlENqyxbt4x/uvKf2Nq7jXnPH4Jbyoz2skZgjGHdSxu44YrbOenc43jvX57NQzc/zurla21K+DWppX0lQtUuHXAUwnHAdRIB6DoY18G4CuMkAtCoVPwJUW/wENogIo2INSLSEMaIKIIoRoQRRBEmlohIYuIYIZL0MFpaEWixNAkhBPPfMo8T330cW9d3c9fv73/dMW77EoGgbdUUAIJilXWzX+DLv/4yP/z0Dzl07qFk3IyNAr4KGoGhiT6AtgnEsiuMMQRRwOotq/nHX/8ja7atQTTxjbc3GOob4q5r7kvNo0+ka0YHSx94jiiMRntpY5Sk5k/IBvHnOqn4c8FzMRkH4zloz0F7Eu1KtCswSiQOL6kAFAZEDDLSiMggA40MY0TgIIIoiSqGEhFGmLS5xMRRGkA0oLEi0GJ5kziuw1GnvJVDj1vE0w89x7OPLNs79i5NxbBq66q6CJw/bT6e41kRuCuMoLkxjYm5j60AfBMYYwjjkM29m/nqVV9l9eL1TF0/D6EFyh/buzYKY5bc/wzbN/dy8nuPp3NaBw/e9BjlwfJoL22MURN/cufIn+eC56GzLibrEGcd4owizgi0J4hdgXHASBIxZwBtkDHIUCBDUIFG+RLpK6Qjkb5MHqvWWTws/RDo5JuojQRaLG+YQmued7z3eLpmdHL37+9n7csbxvxHSfkuU5fMwwjDyi1r+Xrh63zvL7/HjI4ZuMq1InAXTNSoXTMZ2yplDGOMIdIRvUO9fOfa7/Doi4/S1jetHrIfDxgDa15cx0DPIKd+4ETO/Yszufe6B/eKy/34RO5Q86eGI38ZDzKJ+NN5lyjnEOVkugliD3QGdE0ASpLonxaICFQgkAE4vkBVJU7VoCoS5Uikk4jAmp1MchgTGGqRQA1a2MYQi2UPmTqri9M+eDKBH3DTL+8YNyb5KlS0ru4CIGyp8tDyh/iXP/wL3/joN+hs6bTTQnZAN9kI2k4CsdSpGz1XhvjRzT/i5iduTi09Rntlb4zebX3ceuVdnPiu43j3n5/JAzc8wuoX101ybZE2b8g0Apg2eDSmfevir+ASFiRhXhAWBFEO4izEWYNxDMYBpAEtEBpEKJC+QAUQVQRORaBdg+OAUQJHCWStF1BQt4IRJPYwwgiMsALQYtltBMxfNI+T33cC617awCO3LsavvLk5vqOJ0YYbH7+R6e3T+fx7Pk9rvtUaRe9AUzt3J+hh1grAPaTm9Vf2y1z90NX85varmPbw/shQ4VTc0V7eG6Za9rnvjw9z5MmHcdoHT+aJu5eybPGLaD0Zp4cIELKe+q2LP9dNxF/GRWe9VPw5BEVJWBTJVoCoYNA5DbkY5Wqko1FSo7UgjiU6VERVRVwVqIxEu2Ac0dA1DE4q7iSpZUz6vhM1j0BT6yze1Vxhi8VSQyrJocct4ujTjuCZh5/n6YeeH9cz0ttenkphQzvajfmV/jWzO2fz0ZM/ao2iG9AGmvkKT9SzoBWAb4BKmHj9/eCGHxAEIdntBVQ4/ndlHMU8dd8zDPYOceK7j6PYXuCJu5dOsuaQBvGnJEIqcFyEm9b8ZTx0bjjyFxQkQYskbIGwCFGLxhQjvHxIIe9TcAMyToQrYyKt8GNFOfQoVTP4FZeo5KQdwwIja95VCgw4qRm0jJNLkZpFY1RdEFoBaLG8Oo7rcOwZR7HwyAU8dNNjvPzsqnHveOCWM7jlDLEXEQQB//bHf2Nmx0xOf+vp5LzcaC9vjNBsETwxRfX4Vy37EGMMfujz/Nrn+c7Pv0u4UZP184gJZBJpjGHF069QGixz+gdPJl/M8dDNj+FXgtFe2j5gh8ifrKV91XC3bzZJ/UZ5hzBfi/yRCMBWjWwNaWmp0JkvMy03SIdXpqACMiLENw6V2KMvzLGt2kJPJs+AmyVSHkaqJPqnRVorKJGxg4gNJtYInRhGE8cIaTA6XavQVgRaLLsgk8vwjvcez/R5U7njd/eycdXm0V5SczGQ6SkQDEV85/LvMuP/zLD2MCmJ5ar1AXw9rADcTWodvxt6NvCN336D8qMRs1cunLDvjA0rN3HLlXdxxv84hTM/fCr3XPcg5cHKaC9rLzJc8yekTESf4yRp3zTyZ7Iecd5LxF9REdTSvi0QtmhEa0ixtcKM4iAzc/3MyfbS5QxRlFUyIqJqXEo6w3a3SEZFODLGAP1aomNBHClkCFEkki7hQCJChQhSs+nUdNpoDUIiRGy1n8WyCwqteU5Lv8De8uu7RmWk295GhoqZDx8AQP+CbXz9t1/n4k9fzOyu2ZO+M9iY5jaBTNRJIGPbsG6MYIwh1jF9pT6++4fv8vTqpxNDXyOo/TcR2b65h1uvvAs343L2eafT2lEc7SXtJWrTOmRDzZ+DcD3wPMhm0PkMccEjKjqELYqgRRC2CoLWJO0rWiIKxSrTCkPMyfeyX3Y7+3vd7OduZ57byzy3n7luL3PcHma5vczwBpiaLdGWrZLNhpDVxBlDnCHZvMRKRrsyNZZWI8bMifqM4Yn53rNY3iitnS2cc97pOI7i1isnpviDxChaGFHPQC1ZuYR/ve5f6S/1E+t43Ke63ziJ+NNN3CYqVgC+Do1NH7+85Vc8/IfFtL4yBW9gcoziGegd5Par7iHwQ845/wzap7aN9pL2ArURbwKUHOnzl3HRubTho+gQ1MRfiyBoSWv+WiLyLVWmFoeYne9jXraH/TLdzHN7metUmK00M5VkpoyYocrMcAaY7g7Q5Q7R7lXIZ3xUJsJkNNoj2dzUR9CVGEcm66rNF24cL1dvFZ64BymLZXfpnNbOu84/g0rZ5/bf3cNg39BoL2mf4PXnaH1lCg/8/jF+ffuVlP1y/dw1GUksV0Xztgl6fLUCcDeohBXufPpOrrjhF3Q+MYtpT80j190y2svaZ5SHKtx1zf30dffzrvPPoGtm52gvqYk0zPdVElFL+2Y8yHnoQoa46BG0uvhtCr9d4ncI/A4IO2JER0ixrcLUliFm5geYnhmgyxmiVVbJihiV5mdjYwgxhEYQGEVoFDEyPbCkw99FwyZrBtKABCNFXfgNR/9q6x+VHWexjCmmzOrinPPfSc/WXu6+9n4qQ9XRXtI+I7+thWlPzaPjiZn81/WXc/ezd1MNJ8/z35HENIumbhMRKwBfA2MMfuTzwvoX+M4fvkOpOnmnZPgVn/v++yG2rt/GOeedztRZXaO9pCZQm/Er6kbPw5E/D51L0r5hi0tQF3/gdxqizgi306e9vcSs1gHmFnqZleljmjtAmyzjiQgDBEDJaAZMTL9W9OosfTrPQJxjKMpQiVzCWCZNHWaHpVEThA3RvtpYORiOAloFaJnkTJszhXPOO53Na7Zy3/UPT5KmtV1Tqg7xnWu/w4sbXiSIgkkZBaw1gTRrw9YATi6MMURxxLb+bVz8ncsI71R0LJ+RTGCYpAR+yAM3PMLGVZs5+7zTmTp7/Ew9eVVqETUpkxq71Og5afhwCYsOQavEbxP47RB0augKKHaVmdnRz4L2bg5s2cqC3DbmZbYzVQ1SVFVcERMhKBtJv1Zsjz22xQW2Rq1sC1vZHhXoD3OUQ48wctCxRMSpUfSrfeVsrPmbvG9Di2UE0+dO5ayPns66lzfwwI2PEvrhaC9p1BBG0LF8Bv4dgku+exndA91EcTT5RKAZ8Y25SdvEw3YB74L6pI/qEJfecinLHlhB26apo72sMUEYRDx402OcdO5xnP3R07j9d/eybUP3aC/rDdIY/UubPzwXk3GJc6nJc4tKxF8HRB0xbofP1LZBZhb6mZPrZZbXR7sq06YqZESEIpnR6xuHIa2oGpey9ijpLH1Rnr4oT0+YZ7tfoLeaZ6CSpVr2oKyQVYHyQQYgQ4OMQMYg4sQAGm2SqSDG7JCbmGQHd4slZdqcKZz5kdNYu2I9j9y6eJJ5lu6MMIKWdUmJzjPV5fz41h/zxQ98kZZcy6SaFGJo7vi2iXqEtQLwVagGVW5+4mZ+98DVdJrZo72cMUUURjx08+Oc9J7jOOujp3H7VXePw/nBDfV0UjRE/5xUADqERUnQkkT+os6YbFeZuR19LGrdzILsNua5fUxXPp4weMIQGUPJGIaMYih26dUFeqMCvVGe/ihPX5ijP8gxEGQo+RkqVZeo4kJFIdORcMon2UKQkUFEGhHrRPxpDfXC7olcmWKxvD5TZ3Vx1kdOY91L63nk1seJwvE73WNvYLTmqvuv4rB5h/G+Y99HPpMf7SXtM5IUcHPvbyJiBeAOGGMIooBXXljFb//hj0zpnovXb93VdyQKIx6++XFOfu8JnPWR07j1qrvp3do32svaM2pNFTKxf8FRGNdBZxziXDrbtwWiVk2ms8q8zl6ObFvHsYV1zHcrtEuF0/AR0hgcHVCJDRXj0h0V2RS00+0X2e7nGfSzlH0P33eJfAW+QlQlyheoKqgqOBVwfIPyDTIwyJoAjHUiAFMRWI8CYmwU0DLp6JzewZkfPY0NKzfx8C2LrfjbBdntRbrumMtvnv5vDv3pW1m46EA8x5sUUcCkc7d51A+3EwxbA9iAMYZIR2wf3M73f/nv9L9QItfdMiHGvO0NknTwo2zbtJ2zPnIarZ3jrDO6Xt6R1v8phXEVOiOJMpIoL4gKBtEaMq1tgMNaN3JcYS1v9XymSAeHJIJY2ySCnHCQCCo6w/awyOZqKxtKbWweaKWnr0ipN0fUm0H2uji9Cq9f4PaDO5hsTsnglA1OReP4MdKPEUGMiKIRItDoNAJoxd8umJz1PJOFtq5WzvroaWxdv42Hbn5s0qd9Xw0VOOS6W+hbNsS//fLf6RnsmUT+gM1rAGm2qfRYwgrAlJpnUqVa4fJbruDxZYtHe0njgjBtDBnsG+LMD59KoXW8pBmGbVVqdYB1Aegp4qwgykFcMBRaqhzQ0s1R+fW8xQvIClkXfSPuUQgcIVMB6NITFthWKdIzVKDcnyPu81C9Dl6PxOsVZHrB6wOvH7wBgzek8Uoat6xxKjGyGiP8CBFGECVj4EwcD9cCapqb5xjX1IRdzSdRvvpmheC4pdhW4MwPn0pfdz8P3PAoYWDF3+7w6POP8cvbfzVp/AGTFLBs2jZRjxVWADbghz5L7n6We7+ymClP2Lq/3cWvBNx73YPEUczpHzyZbD4z2kvaLUTt/3URKDBKoB2BdhNDZrIxLbkqszN97O8OkRevXUidTGYTVI3LYJhlsJrFL3uIIYUzKHEHBO5Ag+gbMGQGNd6gxh3SOEMxqhwhqxGyGiKDCBoEYGMa2Ng6wJThSS71SSlquLEn2ZKfkQ2m2kKSHAIn5sF9opHNZzj9Q+8gDELuu/5hgurktXrZU7oWz+GuLz/K0/c+jx/6o72cvU4StWuiD+AEPcxaAUjDnN/uDfz0u78g2B6hAnfCjnjbG1RKVe669gFyxSzveO8JON5YTps3mCfXfPWESMyWpUhNmAVGgXAMOSekTVVo2c1PS4ygoj1KkUc1cDEVhSpLnDK4Q+ANptG+mvAbjHGHYpxShFOOUOUQWQkRfghBmArACBPFEGuM2bEOcLJSi/jtLPqSph6FqG9O+nOjMEzFoBWCYx7Xczjl/SeSybrcfe0DVEuT1+R4TxEIHN/F7w75z3+5gk3bNxHG4SSIAoombjARjw+TXgDWLF9K1RKX3PQjXlm7crSXNG4Z6hvirmvuZ+rsKRx3xtuQaiy/vXY0UU5FoEgFoAKjDEJpsiqkVVXJ7kbxtAFCI6nELpXQJfQVoipQFXBL4JYM7pBJxV+MOxjiDIWooQA1FCDLPrISIKoB1AVgiImiJAWsk45goxvr/yb2gXzX7GDiXZvkUov4OU4i+tx0S38WKtlqUUBRG69Xm7QyAQ/y4x2pJG8/62i6ZnRy1+8fYKi/NNpLGre8tOZlLr31UkrVEto0s01i7FCzgGnuJJCJeVwYy2fofYYf+ty+9HZuWPzHCf+taG/Ts7WPe/7wAAcdfgBvPf4Qxm7D2Y7Rs2GPPaFJ6uu0wGiJrx0GdQZ/N94bkTEMaI+hOEs1ctGhQoYCFST+fso3OL5GVXWa5o1QlTBJ9/oNUb9U+BFFSd1frBPxV4v+1dY7Kaml7RMBV4/oOS64LiLjITwPkck0bB7CSy7xXITrIlxn5/SwtNHAsYQQgsNPPJQDDtufe/7wAL3b+kZ7SeMaY+C6R/+bu565Cz/0J+z5zpjmzgKemHtpkgvAWup3zbY1/PDGH1KdBLUR+4JNa7bw4E2PctQph3PAofuP9nJ2QYP4M43CzySmy3HiwSdD0IFk0M+yJWxlayxf80BgjGHQaLbHeQaiLH7oQCQQkUBE6X1GJjF5DmNkEKc1fjGiJvqCKLmMohHijzhOxd+udN9kEivD9X5JCjdJ8eI6iaDzXPA8yHqQzQxvufSyJgg9L5n57KaRwpoQ3CkauOO+bbxevspmI4nNYsFh+3PkyYfx4A2Psnnt1tFezoSgGlb5wQ0/YG332gmcCm5m+nfijoIby4Vae5XGaR8//eXPKd0RM0XPxql4o720CcHK59fQ0l7kpPe8ncG+ElvXbxvtJe2EITlMpF8XQQ+LQBmBDEH4kqFqhk3VNlZnW5im+mmTaqdGEGMMMYZtsaI7amEgyBKkArA20UNGtU0nBs+hRoRxKvb0cJNHellL9xLHI+v+ajJU1OYHJ89k52c30UiFlZCItF5T1Gv9kjQvTvIzSqU1nel33JrIr3kqxjFEib2OETEiFkCMIUYgG2x2dtyPNXFIwy6v/aP2xUIw4kvGhHwt9j4z5k3jpHPfzlP3PcPK5WtGezkTAqfiMmXpbEoy4uftv+AfP/sPtOZbJ9yUkGZ/4ibqJ3jSCkBIUr93LL2Du++5l/aXZoz2ciYUxhieeWQZrZ0tnP7Bk7n5V3cw2Dc02stqoKGJwpi68BJhjApilC9xyoKoJKkMZFmV76LNnYcj1nBEZoA2KVHpid8AEZqNkWFFMIV11Q76/BxhqBCRSO1aGh45rTVMvliKpNloRNBohwOxaPgGKoY7jRGm4ZupGXGxawEyng9jtZo/iVDpZSr6hJvMb8Z1Ma6D8RTGkRhVi+aRFgalk1WiRHgn9joqvYwwkUDEAhPHCFGrs2yssay9Tml72I5CsCGqbMwO769JW6v5xmjpKHLaB0/mledX89xjy+2uaxKO79L+yjQAbr/7To57x9Gce/S55LyJNuwg8e+zvDaTUgDWUr/ru9dz8U0X44fWTmBvoGPNo7c/yTkfO513vO8E7rj63rE1qH2E+BsWgNLXOBWNWxbEgwI/67A108qzYja+dugvbGCO20+XCsgJTdkI+mOXNWE7K6oz2FhpZ6CaRQcKGYmkppBEq9U6jBPLGZlEpKQErRFCYoRJRItJfAaNIBE7kIqKJA0sandYeyLpv81OAjD9nalFCcejGBxu+BD12c018eeC59ZnOOuMg/YU2ksEoFFpfNSA0EkKXoQaGcSIQCL9miVMbX8ngtyIGCF0w74jTT2n66lNkWmMmtSseYxBpFFlUxOB9Xr78bTfRwcv43Lq+09kqG+Ix+98Eh1PzGaF0aYa+vzHjf/BkfOPZL+p++EoZ8JEAROb1OY9l4naBDLpBGCj4fM1//5Hgusd2ivTRntZE5agGnDf9Q/zno+fzTGnH8mjtz+Rptd2B7HD5a54M4ImOVkbbUDHiDiJCkk/QlUVTkniegLtSgKVYZNppxo59AYFpmUH6HJKFJSPrx0q2mNb2MKmSivbykUqVQ8TSESciA8AJHWfQelIjFNrN05S0WbHiJIQCJFO/RAiERVGNjSB1J7F8L/FCOFHPQpVEyYjBM0b3m/7kgbxV7N7kSqt/Usjf56LznnorEOcdYizEu1JtANapW6PaXOPDA0qFX7KGe4EFvXIXlLwXU8J75ByF3WT6bQDudFSyJAKv6RZxwiDqHVtS21F4G4gpeCYM46i2F7kpl/eTlAdQ18YJxgdL06jujbi2vhG/vqrn6IlXwSYECJw2LqlWfc3MZl0AhDAj3wefe4x7rnmIXJ942x82ThkoGeQ+//4MGd99DS6N/Xw0tOvvMatR9qy1H366r/eQcDscibubn5c65m51Fw5iiGMEEGEqihcN40gpabBYeTR7bcxVMmyNttBIeOTc0KMEURGUg49hvwMlapLVHEQoUiFRKLztCOIPRIRJlTiRBLIxKcuVIgoTiKCUTwcldQ6ERENzSq1rfZ0dy36zIhUpNjFdSN9BMfiIa4h0pY2Zwilhhs30mYPnXWJ8x5xXhHlFFFOEGdSM+/aEU6LpA4zNCgfHF+iKxJHCaSSyLrAFMnbTcYYKRCNX1ZkY/2hHK4vrL0/a/s01hgdJ69brJOUsk5FuK6pwLG4v0efg45YwMIjFnD7Vfcw2DuWSkYmHt5gDgbhzt/ex9v+9DDeceTJZNzxYeL/eiSHQRsBfD0mlQA0xhDrmO6Bbn544w+pVCMcbNPHvmDDyk08ee/TnHDOMfRu66N74/Zd3KoWUWlMsdGQeqvdpqHezZhUDzbWXNVu+/onWUMqjmKNkUkEUPgBSgpQAoSbPGoskYEkqkiqQ4pqNktPJka6GoRBCIhjiY4kJpQIXyKDtP5PgFYQu6RCQIIwGCmQjkaGGhlKRKSSxpA4hkgnYrBh8geNNWm1aNMOkb76ftAGY3Q9FYnW9RSy0A1CsH6fu7e/9g0j3wdihNefqotAPAedcdE5l6jgEBUkYV4kM5yzJALQTe/RgIhABQJVBV0BR0mQTvJai4bmX4BIJoKw0Sut7hnYMFGk9t6slxOYpJQglknzjojrvxbo5ESiYezs67HD1NlTOP7sY1h81xI2rt482suZNJSqZf7jxh/ylgWHML19OmoXTW7jjaZHACfox3VSCUCAalDldw/+jufXPs8cDh7t5Uwqlj3+AlNndXHK+07g5l/dQbVcs92ppT7l8AlfDJ+RhZANtVeMiHYZYxBG14XM7kW3dji4GYPRqeCKIgiSk7+UEteA0A4yFQ9hReCUJXFGEnsK7YGRBlMLBhkQWiSp36jWpyEwDmhjiIRAKjAuSA9kqJChTKxhokQMishBxEmzAloj4mFRJ3Z6fo3CtybodHpbPSz+apHEdEt+NokQrYlAM9rRqYaUas3qpfYeSKd71Bs+PA+T8dA5hyifiL+gKAgLgqgAUQ60ZzBu8lyEBhEJYl+gvCQaa9RwI06NugNgTeTVInap7yC16SFKJU0mjV9OdK3LOOkwJooQoaj3aNcD1LXaQisC6+QKWU55/wmsfWk9y59cMdrLmXQ8s+ZZrn74av7XWf+LQqYw2st585jmRgAnKpNGABpjCKKAFze+yC/v/eWEdUEfy8Sx5tHbnuA9f3k2x57xNh666TG0Tk+PMk3zNRj81qc1pKm5nQWgGY6QaZOm3RqjXQ3CaEcaC/prd6rTdF0YgRTIanIAcUzNGkahfEFUSVOMGUHsgnFEmiqmLgSB+vndKNCCpP7PTXwG49QfMLGbSW1nItnwb516EqZbKtKEbnhOhvr1wwbWqfir7ZdaGrkmTGrPMa4JwcaOVxLB2Lj4fcKOkV/Z8CUgfS84Kmn88JxU/CWRvzjnEBUUQVEQtAiiIoRFg87HiIxGuTEg0FqgQ4muyrRBJJ34ggR08iKlSCESb0aVei/W1qYkxhnuMDZO7f2a7C4RJ5FkGcapt2NSOlCvK6zVnCLSN8S+3s9jE6kkx535NgTw6G1P2KaPUUDrmF/c/QtOO/Q0Dp17KK7jjusoYLNTwNYHcBzTOO7tsut/ysDGIdwwM2Ff1LFMeajCAzc8wrvOP4PNa7fy0jOrRtZ4pQX+tbFew6m2XaTbTCp00hFpIhZJKleIet2caYwE1kIxUC/4HxEMrKWCiZJUoAGpNSJyk85RX+FkVRr9k8SpANSeSBoOUjGolamPk0vSvyb5pJlahDDd0iihrBtFiwYBmNSs1YypExFYazJImxpSwVa/rHkZxkkkquZ5V68rjJNNRDKpcYuTfVbveNUSwyg1KzRGf+u1drJu0Fz3+HPTbt+sS5xTRHlFmE8jf0UIWzWmJSZTCMhmQnJu0kQQxgo/cqiUPWLHAZG8OMKASNuzG6sMhJIQpg03aUTSOArjSrQj65dIUQ/mySjZ7yZQSD8aLmFIazCNNiA1wqQ2QBM1r7SHHHT4Aex/yDxuvfIuKnbG7z5HGIFbytDnD/DTP/6MCz99Aa1qfHsDmiZP75ion9RJIQABgijg/mX389QfnmXu84cA1Av0LfuWzWu38tQDz3L82cfQvbmPvu0Dqa9bQ3dn7YSfpv6SdJ0YbgKpRcPq9XJxfXKGSIWO0bohZZo+eD3q1/DvhppDIIn6RHH67+RxVKyRoYMOHKSnUJkkkpQIQUPsCWJPoD2DcNMGBGnQ6UzhWoSw/tCpN2Ai7pJI4E5iMGak+Ktvtejf8M+JoEynmNQEYLSD712UbETDJshEEmr1atTq1dJ08F6PUCU7ozaPd2StX0O9X93g2cFkHHQ2rfvLO4QFSVgUhKn4ozWi0Fqlo1Cm1avS4vpoI6jGDkNhhh6VZ0hmiQCMStL1WqTiejh8K5VGODJ5+ql1j3EV2pVoVxC7STc3MvkeWa8xjCTS1yglUOm3iFpUutbQk9Reivrzn7inl9enY1o7x511NE/d+zRb1o09s/jJgKo6zL7nYMDw+OalPHTSQ5xxxBlk3exoL+1N0dwmkNd6HEMURUiZlA01imZjDHGcuAk4TmKzY4xBa43Wun7daDHhBWCt8WP74HZ+fOuPCYKAQjypJ+CNCZY9/iKz9p/Jiecexx2/vz/RW7XuznREl/GcNOqSRAQTASWGU59pnZyI0rRtWDP1jTEyGk5z1iItxjDCxFfsKAQbfqyll6Oo/m8R63SKh0JGCh2qpHEjTu1eNESIxMvPSSJDRpkkMugZjDKgDEhTfxyTChDipEZNxIkATP5NKgKTxoFhwSdGCsJUJMpaRDFNVyfRxNT3Lt1EGCOCqG6CTBgl0zCi1AcvjlPrGdLmE2i+QGlI+dbNnYcjfkm6V9VFH45KDJ5dJ/H5yzlEOUVQTOv+ihC1GExrRKGtyoyWAWbmBujwSrSrCqFRlHSGvjCPFIl4HtQCHQmiSNVFeGLXIzFCJPsrSp63qdn3uHJY6LugXTEs6msWM6HAcYbfW6ph+ohIO4LREiFNcoKaxFFA13M4+dy3s2XtVpY9Yev+RgvBsFuB7/tceuulHHXAUeO6IUQ3vQlk1/vAGMMtt9zCLbfcgud5fOELX2Du3Ln1fbZ48WJ+8pOfkM/nueiii3Ach40bN3LRRRdRrVY588wzef/73z9q+3jCC0AAP/C56eZbWf34eopDHaO9HAuCKNI8cseTvO+T53DocYfwzOKXkpP9Dqa+xlNoV40o2q/VW4nYJCfqIEYEjbNco2QCh4yHmx8gTQE3NBlQj0ExUuSYZItrTRQ1MZhG0UKFCR1E6CAig4wVwihq3b7aST37RJIGNp7BZDTCi1GuRimNkjqpvTOJY73WAp12EcexSCNzqTCsC8DUVDpmuNGkQSTWo4ihSGcOC1RokIFAhRIZaGQgkY5M9lcQpb52oqFTNYkACmTacNzMxhAxfFn31AMhG5o86qLPAVdhHAfcxNzZeIo4O2z1Uk/7thh0a0S+JRF/BxS72S+7nU5Vok2VCYxDf5xjm2pNmnSNJIwV5VCiQ0EcyWTfpXV5RoB01bAAVImfYOwJ4gxppJekAaimZTXIQKD9Wh1oUgMgYp2+T+LkNU0jnbXSwsncDHLY8YfQ2tnCHy+/lbgWcbeMKu5QhpWPruXWBXdw3oc+TD6TH+0lvWGaawS9a/r6+vjlL3/JD3/4Q5YsWcJll13GBRdcUP/9wQcfzN/93d/xL//yL3UP4v/6r//ipJNO4uSTT+Zzn/scJ554IlOnTm3aWveECS0AaxM/Nm7YxB3feZDp6+eP9pIsAGnTx0DvEI/f/TQnnXscm7b0s61nCJPxMLmkuzPOOsQZSZQRSbQlTaPWol4yMqjAoHyFqsbIqkI6ISJQEKpEsNXm69Yfeod0b6OHW+1yx63u32ZIc4fDxsFSIByZpFtrUaSkpCwRg24i/lQuwvMispmQrBPiqRhXxnXtqY0g0opQS6JYEWlJHEtiLdGxQGuJ1gKjBSZOxKKJBaTNJCJMm0rCZIZxIvpqlwYZgAokytcoXyH9GOlIpEqib4n/XW3fgInixJyatA7O7DDPbk9e69plg/gWta5aSKJ+rptGf53h6G96qT2FzqSd11mZiL+cIGyBsNUQt8fk26vMbu/nwOI2FuU2sb/XQ7sMKQhD2UCPKuOJmLL2KEUZhjIZ/IxLlFHEYSKWk9rHJKqXCOtaFDfxE4wzqQDMJOJPu2Z4Qp8WKD/1HRRphDaSyEAh3cTnEaUS8VerZ93pi8fkYfrcqRxx0mE8cMMj1u9vDFFc10FxXQe3rb2fU094B/vNnTcuJ4Q0uwnEGHj4oYcol0p0dXVxyimnIKVk8+bNtLS0MHXqVA4//HB++ctfEkURrpv4T7W1tdHV1VXff3Ec88orr/Dxj3+czs5Opk2bxvr1660A3BsYDNWgypV3/YYtm7chsanf0UeMEACrVmxg3lu2cMLZR3PLzU/gK0GcT3zdwnxyso+ziYHyTgIwFKiqwakKHE/iuMl0B+kohC+TqEuafqs9dE18juwCZqTgq/nv1e1lIFFpJA8eC5BpWq/WnVsTfg3iz7gG4xlkJiabDShkA9oyVVrcKnkVkFchSmhUOisuNpLISCItCY0i0ir5Ob0uEYiKIE63yCGIHMJQEQUKHSjiQCICkQi/AGRA/d/KB+UpHM+gPIFyRNpsI5PO13qNZSpNIhAmTjSwbvTEez3RsgvRV3/dqTd51EawoRyE56b2Lg7GS0e6ZRx0rekmI4gyyXshykGUT8Sfbo3ItVWZ097HopbNvCW3kUWZXmYqcIWDQhCiyccBxvTTF+fpcQv0unmGXI/Ic9Be0tWdpPCTer/aBBcjqDf4xNlU/GUMOpNazKQ3ErFIusFl2lgSClQgko7jtGu4VutYF3+TVAN6GZcT3nUsq19Yx6pla0d7OZYG0gIZNm3cwm/uuoq//7MvUFCF+vXjhb1RWSGVwnEcHGdYNr1ZYWxGuQRkwgpAYwxhFLJ8w3Kue+w6Ws3M0V6SBaiLgtT2RSN44uHlvPcvzuCQYw/iqRfWEBYcwhaZFPjXPN0yYJzUb0+nTRIBOBVBXEnsVUyaJlaOQCqRNj7sIADF8OMjhrsxRa2zOE4bSmrCsRZBTAOBIzqQ085OkX6IE/GXRiqdJEIkPI2XCSlmfTqzFaZkh+h0S7SqCq2qQlZGeCJCoes6QCOJjSRGJJdGEqEItMI3LuXYo6w9BqMsg2GGwTBLKfAo+x6+7xIFishXxH4qBH1BHICqph54LjiOTNYqBSr9XiSBmsG0IdU2aRND0h0sd+/IWhc4aYq3IbI43PGddnkLkXj7NaT+46ybCL+cIspKomz6JSBDXfzF+aTho9haYXZbP29p3cSR+fUs8gaZqiSK4Tm9rpF0KY+IkO54gC1uK0W3SJ+XxXd1MjYuNMR6OOJXa9KpvZaxB3HWoLMGk9VIL8Zxkwiu0UkaOZYOCImMBdIn8Rx0RWIXU/MPbDQ5R6QTBiaXCnzrCW8hV8hxx+/uQzdG5y1jB2P4w6N/4NzT38Vb570Vz/HGWRRQNFkECo4//nje/a53jbh2+vTpDA4OsmXLFpYuXcoBBxyAlJLly5dz0EEHIYSgWq0SxzHVapVCocCBBx7IU089RT6fZ9u2bcyZM6eZC90jJqQArM/7DSpcftfl9Jf6aMUKwNFH1NOm1OxeHMVgJeTxx1dwwllH8kppkA1hiaAtTfEVDXFRI7Ia4Wik0uhYEEeKyJdEZYlTEqkli8B1qUcDZZA2iTSM8zKpzYiRDbWAqagTutY9m5owh2mnbE0Mpk0kSdRK1b3gtJN0hmo3qQ1L0oSJUHBzEYVcQEe2wtTsINO9Aaa6g7SrMu2qTF6E5ESMJwwKg0rr8VKTGmrtIhEQGYFvBEPaYUB79MYFtkdFtodFuoMCvUGeAT9Lyc9Q9R0i3yH2FdpLhKD2BLqaNC/o1K7GVYwYgSFrtZGiwcC4Ns1CNKbGYVi0iOGLVPwNR/pqkT85HPlLo2HCTVNLnovJZ1Px59RHuoV5QZRLIn5xLo3A5TUmH+MVQrpah5jb0suhxY28LbeJA92QvFD19dffdUIgDXRKxTSnRLtTIe8EZJwI5cRJjambRHiNEI2WgEn61zPJljXIbISbjch4ERknQhtBrCV+4ODHSWOJdlPjb0VdZI8oORhP59EmM3VWF289/i3cf8MjlAZKo70cy2vQO9TLFXdfwQXnX4Cr0olI40QEjpgD0Iz7e5Xr29vb+eQnP8l3vvMdMpkMn//85wmCgMsvv5yvfOUrrFu3josuuoje3l4uuOACvvzlL/PpT3+aiy66iHvvvZc/+7M/Y8qUKU1c6Z4xIQUgQBAHPLXyKe565q5J9N16rNMgCNLOT5yk1uuVdduYs62Pt590MNcufYagNSZsSzo7cy0+xVyVnBuScSKC2KEcupSrHpVShiDrpqk2UkGWRANlYOqGysnDp+a/MokU1gr4gWE7lcaJHEGMDFS9+aNxKkStO9m4sqE7tJYiJBELuZhczqc9W2FadpAZmQFmun1McwbolGU6VERBSLJC4QiZTqF47QOsAWIifBMyoIfYGm9nc1Rkk9fO5qCNbq9Ij5en38tS9jz8jEvsK2JfYTxRF6rGITVDlknUCwcn3U1SJ6HOeiQwFolFTMNMYrMLAViri2x8jYfTvcORP2rdvp6bCK6Mi857dfEX1ka6FQRhviHil4/x8iEthQpTC0MsKGzj0Pwm3prpZbYD6jV8y4QQZJBMlRFtqkzB8cmoGOVoIkdj3LQZRybvHURS32cc0BkNGY2TjcjlAgpeQM4NyTkhkZb4scOQzBBFiihUaMekTUvUO9eNEDuvbXycS5uG4zocf/YxrHtlA6tfsKnf8cDtS27nwyd8mOMPPh7PGT9jUw2iyU0gr35cOfvssznjjDOSL5ppXfO3v/1tlFIccsghXHrppfXbO45Da2sr3/72tzHGoNTodllPOAFYi/6VqiWu/ckNtNw3DRlJhLb1f6NOTXDVGgDSCKDxHCJX8vDyV3j/+4/joEUzWTy0DtMR0NpeYXZLHzNzA7Q5FYqqSll79EV5uv0iG7Ot9HkFAsfDpH6BOvXhU75IfPXi4cdOUnzpyTn9GahbqiRWHhIZGJSfGP7KIDUFjnW9VTYRf0mHcmIMnUYhs0mqkFxMNhfQnq0yNTvEjMwAs9y+RACqEh0SWqWHk9al7u5BQAAShYOhoKBTxnTKHlpllYLyyamArArJqIgBJ8uQm6HiuISuQ+ymUyychkkYSaguTf0qasJP1GOPDEfydNwwY5jhdPCOzR21+r6dRF+D+FMS47kgBTrrEBXcpLu3IFJvPxJ7l6LGFGK8YkBLvsrU/BCz833Mz3ZzWHYrC9yAFinTh3/9fdiuBJ2qTFH5ZJ0QR2lCpYldiTYGIdPnVZvq4mpkJsbNRORzAW3ZCq2uT95J9rMfuwxFHtoIyq5HpHQSGZa1DuGRXzRG1J1OMhYeuYD2qW3c98eH7bSPMY6IJVOWzME4mqu6ruatX3rruIoCNrsJ5LUQQoyoCwTqPzeKwkaUUjtdNxpMOAEIienzYyse46mHnqZlXedoL8cC1BSYqNXf1QVgavWSUXSHFR5ZvZrjjpjPi6s2I1r62L9tO4e2bOQAr5tOVaFVRpSNoifOsiHbxkvedFZ7XWxxWyg7OQLHqXu1qSBpFKkJQJNqncScefhnYERjiQwMTq1mrqpQQWo1E+q66DGORGcSW5KkMUEQ5SHKG3RB4xZC2vIVpuUGmZnpZ5bby0y3j+mqzBQpKEh3RJ3aHu/N9O8yKKYqQ0CZqnHwHTdpIDG1VChIYahKTSAdIukQS5JO1BGqRA77I5okFSxrwi2MEDICrYZtdXYpABtEX+MUlwZjZyMlpCJU55IIYJR3CFud+kSPeuq/ReO0BrS2VJheGGROvpcDsts4KLOd/R2fLiX2aFqBEIIckimqQqtTIasiHBUjlSZWBpzEsBtD4tfoGJQb42Uj8hmftkyVjkyFVrdKVoa4MqYkNKGRdVuf+mOl/SG1WtHG+dX1yOkkSk20dBR526lH8NR9zzDQMzjay7G8DsIIipvaAXh08WKeePkJTnnLKWTczOgubDeplWs3Cz1BP6sTSgDWRr4NVYe44u4r8EMfjwkw2HqiUI8SpVMflKxH0uKMJMrC0u6NzNfTOH3hHFaXV3BE63qOza1nfzciJyQKiUZTNUPMd4fockq0OlVWqGmsV+0Mqjxh2tmp/HSqRpweDNIC//pWi9LQEAEMQAWCuArKkzhe0mWsfJmkhdOuX+MkU0CinBwWfzmI8waZD2nJV5mWG2JWrp85mR7muL1MVxW6pKQg3d2OWL3uLhWCLA5dMmBIlakYD984hNqp2x4qoXGkS1VpqsoQKoOWikioem2aMCKZhGFIvUwYztjXBFzDDOFhixwS4ScYGelLo3yNtZIoOaJuMs45ICHKSYKWVPwV0u7etphsa5VprYPsV+zhwPxWFma2scCt0KUEzhscUyURdMqINlUhq0IcqZHKIJROHX+S9K9wNMrVZLyw3r3d7pXp8kq0KB9XRkiSVHhFeihhhvV0evYZFoEMi8CdipOafaoaewgpOPq0IxjoGeDFJS+P9nIse0g1TGrpj15wNK7jjo8Rcam/avMY48/3DTKhBCBAGIU88uIjLH55MR3MGu3lWEbQ0HiRigWjGmroMoKKG3Hf5hf5y6MXMa0kOUht4kA3JiuGayUUgjyCuQ7kZS95EeLJCEdq1ivNoJcl9DxiXyYeeRHDKWBJfSKHkYBMqzu0SMyWA4n0E083pyLQFUHsGZyqQQWiXiuoVdJUEaXRvzgLcS5N/eZD2nNJ3d9Mt49ZTh8zVIUpUpKXeyeN4gqBJzQOMa5IPAYzMiJQIbGpNXikL4EwBCRGqVFtlllN/NRCommdpJQS6aRTVmrd0SMEYE0lUo/6JWKvId3sDFuhaCexS9GOIMortIKwIAhaE/EXFQ2mLaLQVmFm2wAHtmzl0NxG3pLZzlwHMmLPUua7oiihRSZRPCU1UmpE7X2BQQiDcjWeF5HzQoquT4tbpc2t0qKSVLtMTbzTJvKkg1gLqBl01ya01Eb36R18JY1JRu5NAmbtP4P9F83j1t/cRRRGo70cyxvgsRWP8diKx3jnW985LqKA6Sd5tJcx5pkwArAx+vfLe39JEAWjvSTLjtTqnxoEIPWIUGK1oTOGLdFWNleynDTlYFqGHiIrdv7GmfxsmCId3poZwhVr8UREVoVs8lrpzeap+i5xqNCRrD++kAapkm5ipQxSJrVIRifdnHGQNEzEVZlajwhUJrGaUX46bi02GJnUGcaZpEvV5AUHz5lKoUPQWqwwPd/C3Fye2W4L052pTFOGnHD2kp+WoapDcrFLh9eCiQpkojyV2KOqXfw48Q+sewhGiiBMuoSNL5FViaoKnCqoKonY9U2a+h7uik5GmpmGZpCG17TW7VqL8ilZt+XRjkyjriJxkkmnpcybP41MxmX+AdMptxninMHkYzLFgK5CibkFlwOzMQtch6lqP1STfDzbjWZ/J0uvnEfG6aLkewS+kwi4VCArR+O5ETk3ouj5tDg+RadKUfl4MhExsZHkojwFL0+Lm2eayhO7Lk5G4RbBaze4QzHOUIQqB1ANwPcxUTq3WjeI6T0Qg3GsWbV8DX5l7B/jXM/h2DOO4pXnVrFlrZ31O17xI59f3vtL3r7w7fVmkLEdBWzu2iaqmJwwAhCS6N/jLz7O84+8SM5vQVXd0V6SpU4t/MRwp6isCYThxg2d0XgZn82lx+iacTQd+UOJ/ede5R6TWRXt0uGwTBVXrCcnQ9rdLjZ4bQwEOSqhSxCrempPCoOrYjwV48gYVyVTI2uTOEqBSyXwqFZd4rKL9hQqHf2lqumkjShpoNBOMhEiysHUriL/fOb70MrHkQE5FVBQATkRkBUGR8i9dgjRxuBhaNEO84xLkJpIx0i0EWgz3NKRBKJE3b7E1CJXcS1yJZIxe7UIljH19HhN9Al2TGOmzSS1pofGBoi01LDWCDF8KWjLZ+koFvjgCUfyzrCCUInwyjohBeXTonyKIsYRzZXNxsAxRjA/yjMYZYliidZyREmjlBopDY7QOFLjihglNQqNFMn7RSMItEOgFUHsEEVJs5CM0mkskUGG1L0ohU5nAe9opbMnhmVC0NbZwqVf+TlL7n+2iXtl73Dg4QdQbCty1zX3j7rpreWN4fXnyG1u4dm+ZSw+bTGnvfW0MR8F3JdNIOOZCSEA652/folf33kl7Q/NxKlY8TfmaOyAbBSC9dQsoAyuEyPpZqj8OLNbTmQoWIkx5V3fZfottIhikeeTERtoU2Xa3TLbgyIDUZZK7KKNTGr7hcaTMZ6MyMiIjEpquXRqujwYZugPc/T7WfozOapebVqExPES82kZUq8n1E4StRRZgREx33/6GoRcw/xCNwuzW9jf6WGWAwW5d96P2hi2xSHroizrow62hq30hgUGoix+7BBqRWwSw2GDINYCbSRBrKiGDn7oEPguuqKQlSQa6FTSqSFVkkhgaOqCJhl512CcTSr41HBqN3ZJpmvURL1DajuT/lsl6dZj9t+PfzrrHL7/xJ0s7VtJoeAzpTDEgmI3b8lv5K2Z7czeCzYJ2hieCRzuHFjIMz2zGahk8asuRos0Qmxw3YhcJqTgBbR6Sfo3r3zyKkAJTaAdqtplu1+gu1qkp5Sn0p9B9Tt4/QKvz5DpN3gDEc6Ajyz7UE02E0aYKGoQg7vfEetmXL506edxvbF/fMsXcxz1jrfyzMPPMdhnx72NV9pXTKN9xTSifMCVd/2G4w4+bsxHAU39S2/z7m8iMiEEICS+f0tWLmHxS4uZxvxxN7pmUtGYChaN0aNkU8LgiJigsgRaDsPLHYlffvi171IICjgc6Ma0yG46VJltbgu9cZ7BOEtkFLGRSGHwRIQnI7IiJCtDnNToWCMYjLP0R3m6M0W2eC1s9wr1msLQS+oDZSDSsXCpT5wHxkkq/gNdQVAijEuE8RCRHERrgTZuUw+WJvXo2x4HrI6yrAtdNgQu3aFiIBSUIkOoNVE631aIVAKmnaoaiRYKoxwixyXwHGKduBdLLVBGoBI3FFS9cdskk8zSCGF9LWl6N3ZS4ecl+yT2wLjJRBTtkNRdKkAajDKUMlWMMEReCZXtpZAp0+n1McPZxCy5iS4MRtdGpzWP2GiqkcdAGNDvhwxUFWGFZMRf2hDixDG+CQl0SKQjQh2TU4asTDqkfS2oxoLtPvSWNYNDEXFJ4gxpoiGIhwx6SBMPRaihKrKUir9qFWoCsJYC3oNTlRtGmHHSknjocYsIg4gXnrKNH+OZxnPpYyse5elVT3PiohPHri9grcm+mbOAm3ZPY4sJIQCNMfgVnxt/fRuZ5S2IqDm1Qpa9SPrZbKytqHXqCmGQGDAVqqVHyBVPJ6wuQ+u+175LIciimOsY2mSJblWiV2foj3P4xiFIrVFckTRK5GRAXoRJei9dScm4DOgs27xW2t0ONrrtbHZb6HXyVNwMUUUhq3J4VJgE7WlwEkUk5XA9V82MVJuGDtEmUGse6Ncha6MMa8JONgYdbA1a6AtzlMIM1cghNjJtVDA4UuOIJH3pyBhBEgWNdOIZWHFcqm4iBJMZvDIZJecnUU8VgggFMgIRi3p3az0SqhLRl9RFpvNyPQOeRrjJFJdadE0Ig5SGbNFHKk1bocIMM8j07AD7ZXvY3+tmrhOREc0VzcP7D3yj8GOXMFbEkYQoaeBIugdBK0MYKXzp4MhkzaGW+DI5ZPraoRo5DPpZKr5LHDhJA1FIkgKOEqGc1EyOnKBiGhcyQWnrauWQYxfy0E2PE1THfq2i5fWRocJb1sKNv76Nt33laNyiO2YDLcY0OWo3QT+r414AGmMI45BXnl3NC1euoWvIdv6Oeep2GKnpsE4iSjIGIkE1dOmPcvTGLlX/RTK5o8jkj6EydOfr3nVt7Fe7dMmKiKIu0yp9KkZRNS7GJGlgV2iyIqIgYjLC4InEU843EWVToUNWyMsk5efKGCkMPdJQUR5aOhDJ4ShYw/eNKJaEeAxEWXqiAq2yQosYIic1jmmSfYJJxN/qyGV12MW6oJPuoIUeP89QmMGPHYJY1Q+ASiZ1jokziyajIjwZU5tEG2hFNXapRC6lwKOac/F9hzhwiHwJgUQGAhHVBCB1mxNTb+owGC8RwyKbmCfnMiGem4xM81ScRBCFqY+46yiUcYSmPVNhWjjIVG+QTmeIdlUlJ/bel7iKNmyJWugN8lSrLtp3EKmoT56Pqnf16lgSxQo/UrgqxpUaBIRxkkYv+x6B72J8mfhORiAi0rGCNfuXxg7g9AWcyAg4/MRD6eseYM2LduLHREGFDl3PzWLZmlWs/uAaDjn6YFxn73xJe7Psq1Fw451xLwAB/NDnputuozJUGe2lWF6LerdjejLUBnTirSdqJ85A4AcOPUGBzXGBBXEvmfKj5Fvfg19Zio67X/dhagekLA5TlCQnIsomoGJCYpOkMxWGnDAUhCIjFI5QqTAxxBjaZUBedpMXAQ6JgJLC0CMMZSAOFCaSSSo41SoGkjF12qPPydPttCQiUgbkdUiH9N7092VjDGUTszpyeSWYwhq/i01+G/1BjsEgQzVyiWJJpGWa8k12tUq7nR2hycoomYWb1kFqI4iMxNfJVItSmGEozCRiMHAJAoc4SLqp4yhpGBmeApcYJuMalBeRz0bkMwEtmSptXpWik4joWucsQGQUoVHMyM7EkTFdXonIG6TLKdEuy+RFjLO3on/G0KcVG4N2eqs5wqqLqCRd0GiRpKcl6FiiY0HgSqJIErgOSul0Pxq0lsRaEvoKXVWIQCDCYd/JuvjTu/D9m6hnk5Su6R0sOGx/7rrmPqIwHu3lWJpMebDMTdffzgFH7I/rjNVaVLFHvVWvywT9zI5rAWiMIYoj1nav5a4ldwNj9c1oGS7MSLc0LSbipLFARgYVJvV1YTUprl8XdLDZ7acQrCITbiabP47y4C3s7qdRCIFjJK3SI2NCPB0RpZpCAXnpkBMjTZkFAmEM7VImtYL0YhDpdI3kpB9riS8gBohksp50rlwYKUqRR5/KkVVJjWFeBuRFH3kRk+WNNzUYY4jQbIwMq4JO1qbir7tapBR6VEOHMFZoLeqpXykNitSmT2oyMqLgBLQ7ZVqcKkVZrddAxkZS0hlKcYb+KEd/lGMgzDIUZCgHLn7kEEaKOB5WvDJt2sm4ES0Zn/ZMYpY8xR1iijtIi6xSkAGuiAmNJERR0R4lnWFGZl4SAXTKhO4QrapCTgZ4ou4v03QMsD7KsaHazkA5B2WJqghUJfF4NCIZEygigQlN0p0eSAJXI5RBqDT0mUYITSgRfhIhraV/613UOn0WzQ5HjGGEEBxx0mFsWbeNDas2j/ZyLHuJO568gw90v5uDZh6Eo5wxFwVs9sfN2sCMUYIo4IbFN9AztJ0OZoz2ciyvRd32Ii1+j2NEpJGhRgUm8aCrCIKSw7bBIiuy0+lQZfJyM275EYptH0RVphJHW/f4gXXaNNEoLep9J7vwGDQm8e3rUgF9ukSnU6LHLdDv5hh0MoShIpbpBAyTRMWMEQSBQynwkKnljBIaJ605LIh+ZjkS9QYPJknTR8y6qJUNYVLz1+vnGQq8xIZEy3raVwiDkgYlNZ4Tk3NCWlyfdq/MNG+Qqc4gXc4QnapMVsS46SGzYhRl49IfZ+mJC/REBfqiPL1BnlLkUY1TW530OXgqiSa2uD5T3CGmeQNMdwaY7pSYIkNyEjySPo7AGCrG0K8lPXGOFlVKurJFhCOSSRyBcSgZSVVHycSUJjfODGjDc5WprB3qoDqYQZUkTlmgKqnVTWN3t1uzJzKpmbVBq5H1nCIUyfjAcDg9LjTDXdK7OhNNzHMJAFNmdjJv4Rxuu+puO+93AtM92M1NT97E/37X/8ZRY1BGNH0SyMRkDL5yu4cxhljHbB/Yzk2P35Sk4ixjnOHUr9EGEWtEFCPDGOUrnGpyMo6GJKV8jtWZTvIqSVXGrOXA3HoyuWMpD97MnnzHi4wmQhNBPQVcS/e+GiLNnRalQ4cKaHdKtKoKeaeA50RUlVtPr2JIwoEadKDwfbd+kpci8ZLzRERR+rRIn7Y3IGyMMVRMzPoow7qwk81+G91+gcEgSyV0ibVE60TSCpE0LTgqxlUxWSeZZtHmVpjiDjGjNp3EqTBFCrJCIVOfQo0hMj5lU6Ff97E99tgeF+jOFBmIc5RSc+lEOBtyMqTNqdChSsxwBpjhVOmShrxUODscXgoC2oF2GZEXQwhZRmJwRVKPGKXRwUHtkhM+rpF4byJiuiMaWBHkWDY0k+39RcyggzckcMqJ5Y2ITWpJJFIBWNtE0u3tCIxjhr0NScSejJLo3/DkD3au96s/hYl7UhJCcPiJh7J5zRZr+jzR0XDDYzfysZM/RsbNoGTz7ZreDM2eBDJRxeS4FYCQGD8vue059NU5WkrF0V6O5fWo1cEbg9AxxDFEMSKIkX6MU1E4JYGbEfgZhx6nyItyGgCl2GNQLuWoKe9Bqy6Itr3mxzvRZJrAaMo6pmqgSmL2KzG4gGt0Mj7tVZozhEjsUDJCkxUhGRnhSo0Sw3YqyQMJRK0uLpToqoOf3odMLW08GdEiq7TJbeSExtuDeZrGGDSGzTGsCTvY6LezzS8y4Gcphy5hpGorTiN/GkdpMk5ENo38dXplpnqDzPF62c/tYY7j06EcXEaOVlOAgyErFB0SZqqQfr2dbU4/fTrLoM5Q0Zm0JlJTkD4dskKn8pmmJHnhDLv87OoVMoa8cOiSBl+GdWua2MhkExInjpEYJCFdkqaIQGMMW2JYXJrNmr4ugv4M7oDEHQSnYupTXhKjapOakzPsa+jSIALTZhFJ3TC7MfpXa5AZRuzwzwYvzAmUGu6a0cncg2Zz22/uRmv7jXwi07qqi+i3miVvfY6z/nQKylOv/0eWMce4FYDGGMrlCndeeT/u9uxoL8fyujR2Qw6ngIkiRBChqgqnHOO6oF2JdiShzLDVtBHFir4wz6awH5Gt0O68ncHKjbTKiIxIKz/Tk2mMITQG34BvBBUjqZosoZFEKEQaccqICE2AIKRVekizcyrYkAivwAgC4yR1gDoRKro++zU98cfJSV9EQCjQUhEIw5DM1CePFGRAQfoURB+zHLHLx3yVPUd3HPNK0MYafwpb/Fb6/SzlwEtr/mTq0adxVEzGicmoiIIbUHR9Ot0y070BZrm97O/2MtfRtKQNKa8mfGu7NIsioxQtMmJADzKgS5SMk3QVYyjImA4JLdLBQb668Gu4b2MMnpDEqUoKtUNJZ4hM8vqERhEYh8gMEiufLmXIpYeqNyIEjTH0a8ND5eks6ZtLX28B1e/gDoI7lM559nXS3QwgE6GXbAblpqbWqc3NsJk1qdhLp6jUav8aep3qOzJZfP3HYd03MVSgEIK3Hn8IW9ZtZcs6G/2b6DhVD6pw15X3c9K5b8dzvTEYAWzu/U1ExqUArFm/vPjSi7zw9IrRXo5lt2no/o01RsaIMEIEIVJJlKtwVTIezkgBRhLFHt1hK6Vqhq2FIj69nDvnBJ7116PMprTBIpnOINOkbowkMpIw7TaNUOk4NJF0wYqAvAwwCCQ+DiFF6WGMqR/ETNqtGRqNbyRB6iMYGlm3CEGLdHTacARQhEk3qBGSGIeqhAGZxZGanAzJyYCcDMmKEl3KTaKhr3LgrJk99+mIl8M8r/jTWF9tp7taYNDPEIROMsIMkCQdqhknJu8Op3w73DLT3AFmu73McweY6yQRuN09WIt0DFseh5xStMuYigkQCBSQEQpPqPptd/c+FbJ+8AmMohRnqGoXjUg89rSXiG4G8KkwRQYUpYvaTdHcuA8HteHhSicP9i5g7fZO6PHw+sAbMHhDGlXVKD9OUsAkKeBksolEp+JPeYI4FMRe43QTQS0zJDTImqfzrqJ/O6557Jwrm0L7lDb2WzSXO353r43+TSKWLXmRFa+8xNsOPxJ3L3XuvxEMtgZwdxiXAhBqzR83UvWrSGz4edyQju1Da0SsIYogUAgpUY5KLFWkACRCC2QsCQOXclVRLXsMlmPm5RVlTuWZ3ifJqYCcCnFkXBeBkBwAGmfg1sylMzIir3yK0sc3DrEaQlPFEFCQLrLh5B2YmH4d06+TaSKV2MNPmy20Ti1g0hN+PcijE6NkIjBSEgeKqnTpl1lc2YKSiRkzbGUBJbqkxGs0EmwICIUYtsaal4IWXqjO4OXyNDaV2hioJubDOu3GFdKAAiUNnorJOwFtboUur8Q0N4n8zXMGmOOwR+KvkUQICrIIPKGSbumG3+3x/VHbZ4LQJNY55dgj1IpAJRHApCej9nqW0QS0vUq0dkdqc2f7teaxSgf39h3Iiu3T8LdnyfQJ3AGDN2RwSzGyGiODKCkQhXRGtcQ4AukqpCuJI1mP9MYxCC8x+DYyEYFCmyQarM0O6d9dPHMx/OwnCm85diE9W3rZvGbLaC/Fsg+p+BVuWHwDh73lLWPLEqbpPoAT6/NaY9wJwFrzx5a+Ldz97N14dIz2kiy7jRm2gJE6mYUaSYSMQAqEkqjafGCjEFoio8RiI6oq4rJkcEhzv9zC2QsXsalvG2VdwnViHKmRQiOlqTco1HzwZH0SRkzWiSg6Pq1OlbL2qDoevhkgUGU6TUBWCFwhiYyh38Rsj126oyK9cYHBKJv67KkkAmjELo8yolbrGIOJJGHoUJaJh6AxglArytqjJ+5hljPAdBXQKsERyd/6BgY1bI0zrAw6WVWdwvpKB5tLLfRXcoSpLx+G1JpEJ2JFGLzU46/NrTDFGWSG089sZ4DZb0L87YhsOBi+0furSSADhCYxoi5HHoFORvZpI3FEYluTicOkUxgfmQp1x4ysXYRh0QfgG8OGWPB0dSqP9c9nefcMyt153F6FNwDekMEpxahyiPBjRBAhapErUROAChNpRJyOOjHDtZakVjVGmRFRwHqne+OTrI86FDvovomR/i22F1hw2HweuPFRYtv5O6kwBu5+5i4+1f8J9vP2GzPNIEmp+eivY6wz7gQgQBiH3P/8/Wzt28ocKwDHGYk6MjoZlEYcYSJRr0cThrQ+0EVGDioAVRVEZUGcE0RZxbqhPqpTDAuYz2ObVyVzeJVBSEjCQ8m/hTAIaRBS4zhpY4QbUnBDBrwqldjF9xwC4+Abh6oqkRURGRERIejXGXrjAt1xkb4wx1CURADjWKYCcMSzSkjP6UKTWMNEoFEEBgaNIIwVlchlIMyyNdPCKrfEFGeIFlnFFRolNEPaoz/O0x0W2VRtY1ulSF8lR6mcIao6EEuIAEl9BjEkQtdVmrwKaFUVupwhpjsDzFCagtg7NTo10bXn9z18+1ArqtpJXg+djLDTCBwZk5UhORGQiSOSmGBIYALyQuIKhUwjkRrQxlAyht5YsTYq8lx5Ji8MzWB1Txel7jxOt4PXC5l+jTcQ4wyFyFKACCMII6iJFykQSiGUxEQOJk7KFpL+DdUg5gzaCGoJCFGLBO/4vhjR+CEahOEe7rIxykGHL6AyVGH9yxtGeymWUWBz32YeWv4QszpnoeTYyMaZeu6gOYyT8dt7zLgTgMYYyn6Zm568CW3st83xSWoFQ1ILKESUWGoEiaiSqX+aiBODaBlIHF8SVQRORhAPRSxbvoGjF8xlWf8mKiZMuzJNIopqm0otO5QhcAzC1ZQ9j5IXMZTxKGeTtGMpzjDoZRh0cuSFT1aGaCMYMhkG4hx9UYFSnCGIndRqheRsLw1GpYYyqT+cSUoXSX4wyYxZA1orglgQBYqq7zJQzbDNK5J3Q/KOT1ZFiXcghmrsUIo8SkGGQT9DteIlwq+qkpFstTnECoyX1AlGjib0ZL1JBUAJgys0XpOFX2hiQqMJ0bhCkhXObje01BCQRHuBmjujRiRG2yI13DayXrup0y1EUDGaiBhhYgyCyAjKRlHSLlviIpvCdtZWulg51MXW/lYqvVmcHgevH7xBgzukccoRqhIi/DARf1GUfPEgFWhKg1L1dK4UAiM1UiXRQa2SVL8kGSBSfxqNJ4p6xG84AigA05gCTq7Y4Q/HD5mcx6K3HcgzDy8jDKLX/wPLhENrzY1P3Mh7j3kvGSczJiKAyWdxDKxjjDOuBKAxhkhHrNi4gmfWPDPay7G8YWrNIMmoBBPXAmeiPjtVaoOIY0SokYEiriqcjCT2kkL8Nc9v5vg5+7PQ6eTFTVtSwSeGxV/tZ5Xad7gG7SpiT1HJOARZh2roUgldSlmPoTjDgJujqHxyMkBiqBiXSuzRH+Xq9Wk6nbAhlEmibyZJARonFX9OKgZTozgRkyiEKJkaEUtDLB0Cx2NIaZSjkUqjZOpcJZJ5wnGk0KHE+ArhC1Qg0nm8w4lD7Sa7UAtJ7CqC0KEaOQTaITQOUSqgmikuNIZBHVIyhmqapm0RPi3SIcOepZidNHqnxK6/rwtIDbUT6x1FUl8XCUFkwDeKinEYrJtWF9kUtLOp0sqWUgt9AwXCfg+nX5Hpg0y/wRvUOKUIWQkR1QCCEKIIE0XJ1/yaUEsn1SBASAFSIpykJEGn4950DEYYhE7rABu7fkXNUiZ5T4paaUOD+BPUpjGPT/EHMO+gOShHsXLZmtFeimUUWbpqKS9vfpkj54+dZpCmjoKboIwrAQiJ99+j1z9J8cGpyEgiYvn6f2QZg2gwYlj8pZlMU2sOiWNE5KCCCBM4SNdBuwrHk2hXEg+UWbN8E0dPnc2G57cQoROxJxPRp2XSpanVsJmv9iDOKHRWEgeSUqgII4UfOZQjj6FMhqITkFc+jtDERhIYxVCUSVK/RiY1hanlinHSeZNCpKnYNPonSVKGupbSpqFZRDSIg/+fvT8Pk+Q663zxzzknIpfaq3rfW1J3S2rt+2btsiXLGG/I2NjCwB0weAyYgYFhhsFcfIcBm7m+D/NjhoHhzmMY5s4MNsZgG7CNF1lGkmXte7eWVu9r7VWZGRHnnN8f50RkVmvpbimrMqv6fPSEsisrK+JUZFbGN9/l+7psrhaWtCWKJIwTesobDBcjxjKXWs6PoUugrdufjiRpyQnAWhZT0zF1E5NYRWZNEXB6M1hrSaxhzAqm/Dg3iWFaJszYjFXKzV8+2Td/JZwEUj71LVuEUF7DKTFEGBSuxhMBmRVkSCZ0hTHTy5Gsn4PJIIcbAxyc7WdspofZqQpMRsSTktKEF3+ThngqQ80kyFoCjQSSBJv5zo78iiEEVhn3YcR/jXTiz2YSqSVGOxFopZgzD7o4V3BcDWDrBnNSwYv0QqWU5NzLt/HCEy+FOeynKVILlj2+HhsZ7t/yEOd97Dxi1flmkLbX/y3RaOKiEYDWWow1TMxOcP83fsDArmWdXlKgHVjrRB/OekVYW9y6WkA3LUTEGhEpbKKQkcQqyQuPvsw733kVa6Iqh45NQh4BVOI4AejtO0qgy6ATl4o1qaCRSXQqSTJFPYvoKznvvIpMC+eOzDh/ukhqSirDxE64pNKipcJoAbEXWcq9VwiaHcGidUSY5hVdonmHWX5/8bjMCb8582WtE4BGCUQ5bzwQWKlIlWVaVjgqDSWZFVtZHCWOM3pOMUL3iqcKmDKaMV1h3FSZ0lUQll6TMKNqCGZZrcRJGzfHSIRwndkVmVGSmlRqIqmJhCGWboReLDSR0ES+ssfghbmtMKZ7OZwMcKA+yKHZfkane6lPlRFTinhKEk/6tO+MIZ7VqFqGaGQu8pdmhfizWtNs3hCuD0lohJG+Y11jdeSeB+0aQ/KpH9ba4xqCcpEvXLrX34rjReAiZ/maZYysGuberzzQ6aUEOoSwkv69rg7/vq8/yPt/8j1UShXkKRjdzxehCeTELBoBCJDpjMdffpxdh3ZRob/Tywm8afwV04C1PrRlfSTGWDAaoTVkyhlGK4VQCpQTgBP1oxzdfZTt61Yy9tIRd8H1Hm4oiVHCicC4mTrWZcgaAplAlkp05vzdZjJJqhWNLKZeiuiJE0rSdRdb61KRZakhFr6rOKKhDKkyZJlCegFopU8bWgEahI/gqbQp6Arj6HxqRN4d7aOgubBwYgOkts1IovACN7JkmfMhdEaAgkwqElFiws8AFn4escQgxTE2RZqeNzhVw1pLajVjRnBM9zKme5nQVSyCqkyYNmUklpKosVLJE9YECiGQuBq6ikioqoSyKpMaRUnqpviTmpLIvAg0SJxgTq3rpB7PejiW9nG01sfYTI8XfxHxpCCecl5/sbd7UbMpsp4iGi71a7OsKf6M8WHoPJfrw3NSg1aFbZHb5Jyxb6K1FLkluutz2FgpfBq5KQAFYm4t4CJk2yVbOLz3CGNHxju9lEAX8OLBF3ni5Se44bwbKEWlzi6mzeJvqYrJRSUA0yzla498jVSnhNkfSwWvfKxwjSFWuiigNS4/KjUoBalEKAnSbUJJrJTseGgnV990IY9mllq94VJyUmKVQCnlzXwlqiQxJUlWlqgUslQgM8i0IMsk2sQ0jEBrZ/SsraQapVSjFCUMkXRpSiUNsVQ0tHYiUEY0pEVFpqUNFDAuPSJTXCdzA2QCKrE+qmdbRIQtOodd5NPd5zaa9Wj4FHckMZFwJRDGi00BFokG6qLEKGCswFhJZhSpjWiYUTbFKYNSuu7ZUxSC01YzYSpM6B7GdQ8TWRWDpCZLJDKiKhP6ZcKg1FTFyb21SKzr9JVu1F5DRkTCEPm0sML4sXDNarnMSho2YlpXmMiqjCdVJuoV6rMlmFFE04JoGi/8cvHXUveXN31kLeLP5K9D6yN2xtX2GePsYbSPRmvrmpOMxWiBULZ5sWltAikigPgU8vFp4JYU8CLMA/f0V9l8zga+95UHsEu1RTJwSiRZwtcf+zrXnHNNxwWgcxtbmqKtnSwKAZh7/41Oj/JPz/0TBOPnJUgeBTPuUm8lQhqfXrMIKbDGC0Ahi8L8fTv2Yq49lw1rh9nx1O5mwb50UUIRKVe8nypMqhCZQmqJyKNn+QZoIjIBdR9Bi6ShYlMiaSipDIVFI8iMpC5jImEQwr3RSGkKC5B8Nmwh/uoQ1UE1rBOAie9uzpzIQ9um8PPRz/zWCcOmr5wVTgDKWCKMcufJSoqmEyvJTEw9kxxNFfUkZjKpcCzp5UBlkH3lY5wRT7Auyuj3QhBeP1pnrSXFMGks06ZE3Tq7ltREGAQKQyJaGk84+e58AZRFRkWmxDIrhLZwhQAYXL1fYhUNqzDArI2ZNhWmTIXJrMJUUqbeiDF1RVQXxfl2m5vyIRsakfpaP62xxoD1UT97XPuuMxFrbl4gCmO8ILQ+Je/rPA1e/Is5uyhq/SRN0Sed8G5G/7wQXGSdwBu3ridLNftePNDppQS6iO89+z3Gp8eplqodTQPnf8Jt29/i+dM8JRaFAATIjObx5x/n0MHDjJi1nV5OYF7IU8IuF2qtT5cZ4y6YUjjxl19ApaCeJLz05C62blvL848+jzF2TpQQnza2SYQoKUQaITOFzJSv78ojaK5+UPtaukakKUcZNhbFGLeSzIoJIzU/ecQiSLWbxQteB2iByFyaWTW8EKm5ebOqblGJQaauw9k1vLQIPmOKdy9RiBDmNBPYWGEjhcisq0XTvnFES6QGmQmyVJElkomGYrZeYqxa5WC1n73VYV6sjLOxNMrmeIK1UcKgEpRss4vheHNl6zt/J0zMjCnTMDGpjUitdMbWQpFZRWYlGW5CxslmNgWCssgoi5RSnub1xZDWCjI/FzixEXWrMVYyY8pMmzJTWYXp1M9ETiJEQyIbuQC0bsRb3Tjxl3ivv7zhozXq92qvQ+tmFrsJH7kIzFPAtkjPF3WAkrlXiRZ9Z1vE3/ERQCFoiW0uDqSSbLv4LF58eheNetLp5QS6BGEEB/Yf5PEXnmDF4IqORgHbLdgWz1/nqbF4BGCa8uh/f461f7cNmYQI4NLFNm/ydFx+pTQCIbwY9ILIInj+sRfYdsEtDPRVGDs62Yy0SFcviFLOUiaL/AU89nNfI0CCcE0VxfzXkiQtKbKSt33xDSAVlXk9JvzMWoXKC8Cs7wjO5qZ9VR1U3RLV/MzZukYmGpG4iJTIxYg2c6NOufDLI6OtEaQsQkTKR6XyaFSEMAap3SximQqyhkDXY5KKIqmWmK5UOFrtY291iBcqK1hbmWBdeYz18QRro1lGlKZHuOaMXA5qa5m0Kce0ZNJUqNmSm4ecF7oJvJmJLXwM5Sl+6pe+VjF/2nMfw4aJqPluY3AznrWVTOgeJnSPF4Al6mmETdzEGJW4cy8Ti0wtIjNu017wFee1BSGa5/r416IvRxC5YNTWp4JNIbitpnhNHh/Isy0i8JVNIIszRTW8fJCRVcP80999v9NLCXQRvfuHqP5dP48PPccNF3S+DnCpirZ20vUC0FqLMYaJ0SmevOcZonrnW8wDC0GLEMxrBPOaquOMdY8dOMbEkQnO2LaW0YOjvovTGfdipLt4Wx/BsdbP+7Uo2WwacVYxIMsCkzofvlTnxso+Tep9+vKMrLGSzLrmkcxKsM6rL49C5ZGoqGaIasbNnK1nyCRz0yfyaJQ2zSaEls22/P6FeJDS16MppHEd1JjYRx6VG52XQpYIVAV0TaArCl2WZGXFZKXEdKXKkUo/e6rDDFdXsqIyzeryBKtLkyxT0yxTNSoiIxIGi2XWlpg2JSZ1lbqJMUjXCCM0QlgqMqMqE6oioSo08fGeKCdAW9fUkVpFYlRRcG0tPsoKNVliRpbRVjKlK4xnPYynVWazEmkaYTOf1m9tzmgJ8Fnf2VtE4qwEP9TDGoPvLpl71WhNBfsooGiJAkptsdodUwo3F9j1kDTnAeevnKbWa039tojBRZQCPuO8TYwfnWD08HinlxLoIqR2FkmPf+dppsanqFYqKNHBYM3i+HPqKF0vAAEyk/Hcszs4vP9op5cSWHBs87aw2vBXU58+y0zC80+8xNkXn8Vj9z5FlmZFilgY6Qr9dVREgZwItE4ISGcVo2KJKglMw9nEmFSSeWFnfKqzQMwVf2mm0FKCBZmKIvIX1azfDKqWIRsZop66dGSWjx/z9WhzBCCvyGE0o56urrHoTDUGmUek0giZKmQiUQ3pxF8ZTCm3wRHoksSUFY1yTKNaYazay/7qEC/2LGO4UmNZeZoVpWkGoxq9skFFJq65xAoaNqZhY9d0DN6uxVKWKRWZUhEpFWFQpzBz2GLJcOIvNU4AauNGweXCO7OKWZlQkSkayYwuM5lWmU7L1JIYnaqm+NO+gcaLucJgulX8ybzRyLoaSvBd6BwnAlsaQ2zeCKJ92t0gM4NRAqlw3b7YpiH0cQ0hc/0AoWk1kz9gcVytolLEmds38fSDOzBh7m/gVTi09zDPPbeTkRXDSNGZOkBbmKy3aX9LtKFkcQhAnfGdJ75DlmXOSDdwmmLn3uZREwsvP7ObS68/n5GVgxzac8RdYK1wHYrSCQJrbZF5E0K45hAlvfizqIZAJyATgU4kSRIxm5Qoq6yo/3PdZZKJtMJkUmG6UabRiLHC1eI54efFX576rbnIn2jko8dS14HqbUjII3nHNyTktX85QiCEdMLFRzPz5gSXCjaIzIlA1XCpbB074WcigY5bxGBZkFWcGJzpiZntKTNa7eVgtZ+hao3BUp3BuEZ/VHd2OCIfu+ZEsfYRT+GndDQ7d08tsWmBGVNmMqsylZWZTstkRqGNq72s65iZLKWsMsoywyCo6ZjZrMRUUqaRRpiWyJ8/UVhh3VhAJbGRRGjVnPRBs1EIabBGFylea03L4/xjW+szjU8B+9SyVK7jXIj8A0UegbTHicnm7uamgJuCcDFEAVesWUZPXw+7d+7t9FICXUqaZnz3qe9yxTWXdi4N3BooCLwmXS8AjTVM1aZ4YOcDhCc0MJfmxXJybJKjB45xxjkbOPTyYddEUniuNbWU9eIPIRGJQkQa1ZCosiBqWHRDoBoC05Ck9YiZuISUriGlpmMsziJmKikzUa8wUyuTzcQIJRFGOPE36yN/sz7y1yr+WkePZa7+rxAdRdr31USAExlWuscJ44RgYZjtBaDMtIsElpwFjoolJpLY2IlAEwsvCkGXBVlZoKuKrEeSViPGektM91QYrTTorzQYKNWpRik9KvFdz9bLFrfGyI85KeoAT/aZsxbju6ondZWxtIeJpMpUo0Kq3SxgKSwzUYmS0s4bUGkA59eoFbNJiSxVWO3OvT9Nzig7yn9fCcalodzTLhGy2Q1Mpl03tdZY7Wv9hHnlc5B3DHvxR2YQmUUq42c/y2L2tEvHHy8C55pBC+9Z6epavWBdBALwjO2bOLz/KFPj051eSqBrsdz/3P1M1/8PKqUOp4EDr0tXC8Dc/uWFgy+w+8gelrOx00sKdCnWGF58ahcXXLOdh771qBtMnzeRWJoTRmgW5ItIIhsSG0tUQ2FKFlUXKJ82zWJFPXafYI0R1OMYYwXaCGaSErVaiWw2Rs5KosiZA0c17z03a4hmM1QtdWnfeuIif2mGTVsMiG1r9A+Kpo85QkAU6W6MQEgfqcrFn1Leqy5DpBEiyqDhOoWlj4ChpDPFjtzX2qeDdVmQVf3WI8hqgrRXMdETUauWmK6W6Skl9MYJlSh1Qkzowhsxsm5kXi4BTyUpWLeaqpVMZk4ATjYqzDRKZJnEaNeco6SblRwpdzwhcD6NRtJIInSqIBO09OK4kYD5BBgti1MphQClIZWgJSJzDUJk2kcEc4sY0Yz4tTaIGOMGAGsJmXITaqRASpf3NVa4ukKL7y6nOU7OP43NNLA8riPY5467WATG5ZiN29bz6HefCN5/gddl1+FdvHjoRYb7OpgGDi/RE9LVAhBc+ve+HffRSOudXkqgy9n7/H6uvPUSlq0e5uDuw+5OC2CcwbQxbryX9s0UmUakGTJRqIbGxIKoZIuUqZUSLWJqmSRNI5TSWOtsYLJGhKlFyJp0xsMlFzjKI3/RrE/7+ujfq4o/430OC6Pn41LcBa3CQDiBYiXC6iIK6CxLDCjXIEIm/eQU6Y2xnQjMBaGKJaak0CWJSiQqEajEdw+ngiyJSRJFlkbUyiVmygnlKKMcaUoyI/ZRuYZKMLFACcOEqjJpaoxITfV1jKattTSsZsoI+q1kLO3hWL2XyVqFeq2ESSVoX/8nrdNKyiCUdalWXE2OSSU2le75zJWnFBhlnfjzk1aslKhIYFLjzLMzW3QGi0xDqt1tpp2IzlxjjjW6+BDhD9piB6PdOZYGoQRSALTWitrmFUhQ1B4ipe9Ml65BSfpRiLm10Zz6w+5i+ZoRytVS8P4LnJBaWuOBHQ9w0eaLOjIb2CLa+ifUznrCbqKrBaDF0kgb3P/c/dgufEMMdBdTE9McOzjGprM3NAVgHlEz1rupuGJ+KzUiy1z0LMmQDUUUSUwsMBEuPSec0DKJICkrJ668cbRIhDMdrgmiGYgqzo4lmrXEsxpZS93kCT92jMSnfXXmxZ91URTbmm58vdd4S12gBbwHoSAXfz6SqHXT/kY2t8Ig24/RI1KIUoSMlRPAiXIC0HcROyEo0WlMvaJIK4parIljTRxpSsqlZOtRTOYbKfpkg0FZY1hOU1HRa75lWixHtWFSV1lnFeONChOzbpKHmY0QqfNRzLtNrLRYpTDKelNlfy6McNG/TBTT21z6F7QvPbJCICMXDZSZKASgzEVgppCpF4Gpjw66ETFuDUa3vI5sUQOINu4x+Zg3V/6HieScShXbku4VUrjnRefPiXIpfelbkPMh0l0qAjefvZGj+48xPTnT6aUEuh0L9z13Hz9xy09QKVUWvna/3TWA3fWn2Da6WgAaYxg9OMaRr08yeHDFkn0SAu3BGstLz+7m3Mu28oNvPYrOWi/ezhLG1Qb6i7tyIzuEkshIYZUkioQTSD7qI7TANASmZLG+01cYb/KcT5uYsZS0RWpc2ncmT/s2nPhLM2zmGz+MqzUrxMSrdgq87m9JIRaM8GbZuTgx3mxYe+Hn682kbKYdVe6PqFCxwsYRMo2RvoPYzSsWxZalwnVFJ4JGKSKJDSrWRJETgo2SawrJZwL3qzpDssGAzOjhld3A1lpmjGa/LlPP+tFWMt0oM1srY2Yj1Kzz8xMpLaJO+LSudbd+8El+KoShmOZiJS7VbX20VILJ3ERBoYWbq5y5+coylcjMYhOFSL0/o5KIJE/RApnwHdpNg+7ct1FkBqRBKOMeJ6yv06QZNfTrR4oiCuvmWeed37JZzyksrQHEV6czkYgojtiwdR1Pff/ZkP4NvD5WMPjCCg7NjDP6njH6Nvch1alZQ7VlGeFlekK6VgBaa8l0xvMP7UI+WGHAm8EGAq/HvhcOcPnNFzO0fIBjB8fmftO6qJsQTjVY7aOAqWsIUb6j00oBuGifTAW65ESFVfg5vW7MW9TITZ5dF6zQ1qd9feTPz5zNGz6c+LNvQvzN+WVaooFgcWlErG8o8GlF8maDvM5M+1o3pcA4OxOsRXlTaSwIKxHapVZF6ruifY2kiSVZSZFFlkZsqJdiGmlMI4uQWGKpqYiEHjnGhsgQ2Wb9T974ccxYDmUDGNWLtoJ6EqNnI1RNomacmbNMfS+Gb5S1yjV25PV9vgkZ8KV1/nlxKV+ctyO+KSMS5L0dwvgGDS38OD5QiSysc6TvDBcy9efMd2q3fJaYMyIuj762Xm1k06/SCNe8I32WWvp95FNehK8B9SYyzujcCCc4X5HGaklHF94yC3OVG1o+SE9/NaR/AydEIBjYtQyxR/Lioy+zbuNalFQLWgfYdvG3RMVk1wpAAK01j9/3tBvvFQicBJNjU0yNTbPuzLXHCcA8hepTr8LXf4kWSxAhChsTYZypcpY4g2ijRGEWLIz10z4sUcOiaoZIZmAMspa0RP7SpvjTupnyfdPi75W/E1o0R475TufCO1C33i99REo5a5RMF+bGaENkLEJHyMyJJJUKskSgG64xxsTeNNuLwbQs0aki094cWmoqIqVXJvSIaZapiMhP9jC4kXKHdJVD6QCxrKKtRDdcLaWaFcSzIBtumkfrDGSjBDZy6V0nBr3Qy6OBMEcRmgiEEkUzRt5kI6woRKCLclp04ju/I0GkpEsb+6e7uW/bfLoK8SeL+s3cZiifBmKVE4HC+HXkKWJwHpT5dBF/6xqVfMmhzFUsXgPmB/bR3NxEek40cH7fI9eftYaJ0Ukmx6bm9TiBpYPRhsfve5pr3nFFB+xgRFu9+5aqAulaAWitZbYxy9OPPdPppQQWETrT7H1hPxu3ruOJ+58+Ll3lr7DWgMEV+WcCITJyu5iixEybpp9eJJoC0LjojROABploZEOjSokbydZIwUf/bJZhdeYbCnKrFx+mahst+yrmBufj8yDvIBZ5J7Hwna3SpyCVLvwEpTfJFsZNuRBaoVOJTFxNnfMQ9ILY+wtqPzmlZgSjXgBWZUqfqtMrEyx1hmWEEpIpk3JMC45kfRzN+uhXZRftSqRrpqk5D0U3L9ml1PNst1UWk09sidxtLgSLiJtoasDi37LIDs8JmAnt08KZM+42Ma5bWgoiv6+ii7cl2jcntFA04OT7b5ksE4nCEiZvRPFNwk7k5TOGcy9HaHap56/RlmXnncgiL0/Im0mOHxs4D0gp2LhtPXt37g/mz4FT4slHn6HWqFEtVRe2E/i4P9XAq9O1AlAbzf7R/bx8eHenlxJYZOx5fh/nXLqVnr4qM5Ozx33X+jcH3zWLbo4JwwdWrEXpCJkaTEm5aI7Km0Ksi+pkBpEaZKoRSYboSV1jR5pH/vSriL92RP1eC3vcP71y8mlDi6U5gcL9HhaLsMo3k7ifETghiLFEeZ1ckptK2zk+gqYEWUWgM0FmImZFmWPKUFEZvapBn6xjgdTWKQuYMJJjpsox3cd42oOSJSeGjp+bXLeohmvUKIKcSmAiW4g/4xs7TATG1wYinejCp4eb6WPbTBnnW57Kz7ygbfj0sgCLIs4jvflUkWJes0vNumy7KCbOWOU+JOReiyYGI0XxfKjIi0Ap3Jtuvu9cCPplWWmaovNVnmIRRUVdp1AKrPGR5XaUFbw6Pf09DK8c4sF/fKSt+w0sfV4+tIuDYwcZ7BtsmTA+/7T9XTZMAlk4cv+/p/c8zUx9hgq9nV5SYBExemgMrTUr1i57TQHouoItoBG6yLY5geftQWykkA3XHGJ9p6fwP4t/TGEf0kicOEhTbJo1bV7mLfL3eti5t1a0fNkULQJfE2mdr2A+DUNog9LGN0ZE3itRYUrSTxQRRTRQJoIsA4wkkzEzynJEZfTGg/RHzrrJRIKKyJg0ZcZ0L6NpLxNJlV4VgXV1lsqLwMjXVKq6dgLQi6NchJtIFqlo7ec3O9NnHyX0EUEiL+akxSiwkfs3qiVT7G39ZCz894vBcb4OUiG0r6fUyqVoTf5KafnEkEf+Iuk6kOOmOC2ekcyVFyBAGwlaefHnz3t+3DzS+FpPa6zcc6cUQimscdNY3OvZNO1w2vhaW7FuOVmqGT08duIHBwItTNeneWbfM2xZt4VInvyIyDeNZcmKtnbSlQIQ3Pzfh1982BneBgKnQKOWcGT/MdadtZZdz+55lUd4QWbBagnoZgouNwDW2ndrqsJCxf1oS7SlZZoESYo11qV9s8yLv/w48xn5OxmOO7a1RQexaJaaFYbZ+WQRqTU204jUm0rHTQ9BXZKosnS1gnkHrhLoKGIyrnIo7qdXJVjrxsdVZcK0qTCheziW9jKZVFgeRWB9LV4CMrF+M6iGRqT57GaK1KqMJCaTmFgiSy76WEQEIzcSzkQ+oubTsO4L30Ec+WhhHhw1+KYS4R8mkAZvh6MQmUFl7nVQnB8oOqzz6F8eAcwnruiSF5X5KW8JfggtkdpitESayH3oyF9jre93cxo+fK1hHLku7jhClGL/GvT+lrjXMIWgbM9rbv1Zazm89wiNetKW/QVOH4y1PPTCw9x52Z0LrDaOr5F9kyxRMdmVAtBaSz2p88TuJzq9lMAixFrLvhf2c+5l21CRarGDOQ5j/SxYJwKL7FkeDZPa1VkVUxto1lt5Q+DcMNhmfvKINl0m/o7Hzr0xpil+i7RwLnKVT3U7AUgkCyEoU4VJFUL7nKvwdW+xIolLjMU97I8yDJLERvTIhFlTYlpXONboY6pRJo2VE2GZ6/qVGcjUIlOXXhepds0pxgkkK/O5vv74mUTEEuNT03NSwwZ/7oXzEYxyxQfkfoK4EX8mTxdb0WwOSV13sE0UNjauU9x6Q3FLEUV1aec8Agg6r1P0a/E1BV4Auq5eoUFkLsJYpG+VhMg/By3NPM5hWhQfPGzkPB5FKYZyGeE/cIhMYMmclQy2bZHAKFas2bSSJx94trtexoFFw+O7HqOe1qmWqwvqB9jOl+tSfel3pQA01nBk4gi7j+yhjxWdXk5gEXJw92Euv+USegd6mBx9tc5F/ydt8ppA4bswDUJLrGx66eV2Ks0f9bYfeXrXmEIAWm2aPn/zUI/VPryQzZsYXPEbc33uFChvlq2UM49WTgSKUoQo+7ZcwArZMn9XMRuXORr1YqwgMYoeldAwETUdM9aoUmvEmLLyEUAnAFXq6v5kLv4S7SZu+JFsQgisUpBKTOxNnH000mQSk7m6RDcBxKdz88hfPipOAtJCZMkNpa2QWCERBnQm3HoS0LFAxRIRSZRSbsd+FnPeiNH0+PNb1ExJmzhvKXdWMN59yK0zFm7cnVGuudzXA1po7tPf5jWLWIvxU11sHEO5VLw+C1NwNMLK5qjAN0nfYB89/T0txuqBwKmx++hujk4eZbBncMH8AG3xv8Dr0XUCsJj/e+gFputTQQAG3hCTo1Mk9YQVa5e/hgCEZhjMRUysNYjcR88bR8+xU2n5kbkzfH3kD3zUr70puPnjuN8fU0wWQeYCVzbT4drNzhWZq18rbFq8WMm7g20syaKYSVkl05K6jqiojMxIEh0xWauQ1EpQcdEtZz5tvT+fS6+LorHBNM+t8DVyRiG90LbaRSGdAFRo7fYnjEvnZjBnPrBLA/uImsRFzJQ75hzxFgls5DqPlcqjfRI3gQXfWEMzUpfbv+RNKJI59YYoH4lUvl4x9rWA/vwVz4jEzWvOBWVuc2N8U4pQ2FhiqjGmt4ys+6kiXv4VdjTeKPzNXglXrF1Go9Zgamz6De8jcHozOTvJi4deZPPKzQvnB9jtb71dQtcJQHAdwE++/CTavEbqLhA4AUmScmT/MdZsXsULT750gkc3HYetcdE+4Sds5Ia+ryYAXQoRJx58k4ftupTvyWAKwWCtdNMtfGOIm1crXVRTeRPpyNetGeO0i+++NbHyljn4OcolpjNJkkbEkcZYidaCpB5jZhWy10Xd3JQOJ3CEbZ7qwiw57261OHGujZvYoQ02M9hMIVKJiC0icx3LwsjCGNpF63wdoQSdp2bzdLC3i3EG0s3NFCLMpZ+LaDD5zzd7p1vrjXwF4txT7MVhfgyjgFiAj5zma7ORKJpI8jUgnDB2olZhIonuidB9ZZAS6WcIuxS1+/Dinj/xpqOAazav5si+Y6RJ+qb2Ezh9ya/nN55344Iet502MEvVUqYrBWCWZuz+zgFGnlpDNLvQBpKBJYGFgy8fYtvFW5BKnoR/WTMlWnTKHi/+5jzczhWDpvXnFyP5+jVYZ4aMwU2mkE6ouNS4dAIsbxTxQkhJQeT9Em0eMcPPEk4UjdiJTGtANCSq5ka+uZq43HeQuec1X5YXm3lDmBASmwlQeSe2q1EUmevWlb57V+ThM+HElVT4NK11Fi1eFLqdWh/ls00xlgtCKSC3AfIWOq8z6Nhnln0UrvVxwkcBJejIf8DwrcHGTzoxJdAlgS7jIpK+YUVoX5+oJSaGrCrJeqPiNSeNa2kWRV1qvkbbXNgpoiLFyvXLeeYHz53yzwYCAPF0iZGn1rB76CD6bRoW6HJuCx+owOvRdQLQWMPsVJ3x79QYeWlNp5cTWMQc3neUS2+6iGpflZmJkxlg33KRzNNotF7s827M4x/f7fV+J0vRGeLFi2ixEtRzo0u5tpHCzVJWkihPXebTKrzFi24I17yA11kpqIazfhH46F8e7C/MlP3cXNOcttGsWdR+/y4dTMskE5catl454cWs9fV0/sd8Ktf477voJ77OruWikQf2fLpXzCkFyFPULkKZi1iZCTd7OAOTi0pBMxqJF6GxJfPRPSud6DNl0GXIqmAqFhtbbORFbybdWL7UPTbtlST9EmzkzLu9LRHadbBjhB+l98ajgD19VfoGezm879gb+vlAIJ4tM/LMGsbSGWrTdXqqPSihOr2sgKf7BKAxHDs0GjynAm+aiWNTGGMZXj54kgIwp1XYiVcRfMf/+9W+Xsy01AYeLwSt8D0QXhT5MXpSuChZ4bFn3Sxh3cBNC2l5p5Had/023DGktnk/RrOjVkk39UK7lLQtatp8tNXPanadG9JNNNEKoSPX2Wy8MLKRF3EuqplH9XIlVwyK8SPijtfxNn/o8XVLlmKCitDGCzBZzBe2qU8P+4hi3gDi7vM1hoJivF1WBV0F3WOgVxP3pJRKGXGUIYBGGpEkEVnddT2nvZD0Sx8VjBCpRiWRq9dMXee6laZF1J7663N45RA61a9TQxsInBzHDo5y7NAow8uHUCyMAGxrMmYpvb230FUC0FqLsYY9L+6jXmt0ejmBRU6j3mDy2CQr1y9n7wv73+Beluhf/glpEcF5h7Bw9W7OLgaECw0WHbpSCqLc6MG6tKVOWjzxfFYmr/tTiYvqCT+VI4+GoQQ2Es6ex6imOXKhoFrnKft0s5Zup9qJP7RF5qWDIvJTO5p1gPnXMg/04tOs+ezgnKLZg7np3KIL3LjoX2aQqUFFsmjcEAiMdCJwTvA4n2WsXMRPl0H3WkxfRqkvYai/xsqeKQbiOn1RHYtgPO1hrNHD2KyFkiHrgbQfVCJQiUTWI2QcIVLXte3ORV6n+MZewyvWLWf82ARJ8P8LvElqs3X27TrAmeduxko7/40gp+vb9inSVQIQXMHozj07j5vhGgicOtZYjuw/xop1yzu9lEVOrv5cU4iVrhvXagFCI6SfpSyFH/bkImMyU04Axs4guRjH5h8iU4pZueCzsZF09ox4m0bfZOOibbKwhPFt297uRDghJpuzcYWv05OAaokq2gg/1g9AuOxyLth8nZ1Ln7a8/7zKtUpY6+oZtYFMI1KBUq5eUomm2hO+69gU6Wf8yDjrRun5qJ8cTBkamGVd/wRn9h3hrMoRlqlZBmRChuBA1sfeZJgXyoZSrDFVQ9YL2awgqglMyXskFrOCm00qvBENKGDluuUc2XfMNzYFAm8cayw79+7kOnPVAh50gQ5jLY1GA6UUUTR32om1lizLyLKMSqXiMifWkqYpWmvK5TIyHzLQAbpOAGY64/kDO52lwQKaRgaWJkf2HWXjtvVEpYgsyTq9nEVMS32gEbkkdHcJL+QEzfm53s9PNZQ3aZZFQ0U+k1elttk0kYujyO8QibTNLmtnzm0Lo23AezG677naQdMUf9YW+kdKQSTzrlqJ8VFA5UWgWxfeBJpXSQW3NIDkpszg1pHpIgIqpB/3hkuVC+sbO6yF3P5FeJPoEmRVi+43qP6UZUNTbBk8yvl9+7igcpjNUUpVCpRfxtb4GHvjCfqUpCdOkD0ZWa8hm5Yuxe6ntLjonyzW6+xh8vDlyV8R4zhmaMUgOx59/pReJYHAq2Gx7Ni3g8ws0Htwu8Xfa+zPWssXvvAFvv3tbyOE4BOf+ARnnnlmIfT27dvH7//+76O15oorruDDH/4wjzzyCH/yJ39CHMesWbOGX/mVX6FU6kyza1cJQGstjbTBS4d3dXopgSXC6OFxKj1lqr0VppLgZfbm8XnMfPaswE+hyANztqUpIUIkChl77zrl5uXmQlBkXprkqVHfMOHK1kRxOJmngb0VDUY2o1t5M4b3Miy6hv2CBAKpnHmyylPLynffSvcYo5xZtEtFi8KOpkC0pK9bmkCEsVjhmy98Crywl8nrnKz7XYT0SXMFJrZkFdC9TvyNDE6zbegIl/fv4rLKEdZFAoWcE0kYlIJqrJnlED0qoVzOsBXj5jPH+FnGzphayGZa/o02Qvb0VylXSowdmXhjOwgEjmPX4V000ga95d6FmwncNl59vaOjo3z+85/nD//wD3nsscf4L//lv/B7v/d7xfc/97nPceONN3Lrrbfycz/3c9xyyy184Qtf4B3veAc33HADP/VTP8Xo6CirV69eqF9kDl0lAI01jM+Oc2TiCDEDnV5OYAkwMzmDzjSDIwPBzLZttAgu4adP4BPFhRhzVjEyi7CZxqYKEUmsj1SZSCJ1sbciDZt32zrBJAtBaY2bxJF3+7rxfE1rn9x/URT7dOPRkAKRKqTS2EgiGxIVWe9V6Ey/ReRGxwnrO5JbOnYhD0i2RAHzztpcBKKdMJTCezpH7pcRTpCZXJi6pl10CUzVIPoyBgdm2TQwyoV9e7i8coR1kfS6dO4FRwhBCcmaqEFZZMQqQ0TW29XkU0N4revUKTM40k+WZsxMnkrzVCDw2hyeOMzk7CTDvcMLc8A22sBYa/nGN77B4UOHWLlyJbfffjtSSg4fPszAwAAjIyOcc845/Nf/+l/Jsow4jgHYsWMHH/jAB+jv72fNmjXs3buXO++8k09/+tN88Ytf5JxzzmHZsmVtW+ep0rnk86tgrOHwxGGm6+FCHWgPST1hemKGkVUL9KZz2uAEkPWNEFZnkGbYJMUmCdQTqDUQtTpyNkHWEmQ9RdYyZEO7cW/aNoWWACPzUXJ+VFoJH+FSmNiNoiNSLs2p5CvEWFETqFvsUFK3LpFmyESjEoNqWFSSbyAT17lb2NG0NoLkNjCto99arWDyyGSmEWmGSDQy0chUI1OfCtduZ84sG0zZYquGnt4Ga/omOLfvIJdUDrMuEq8q/loZlpaSyChHGhmZIn1dGJa/olvljTGyapip8RmSRjCADrSHydoUhycOY6w58YPfLPNQ/7dyxQo2bNjAypUri79RIQTGOAN2a11zS+vfr5QS40tWtNYIIbjnnnv42Z/9WT71qU+xd+9e9uzZ0/7FniRdIwCLDuCje0iz0HUWaA/GWMYOjzOyaqjTS1li+CI540Sg1QZrtJuJnGbYNIWkuYlGimxkyFQjUuNMm/NGizzFKmkaIkfC1w76+rbYCUHbIgJFXu92vCizuSjVLeLMbTLRyMSgErz485Y0qW0ZIUdzXRJvHu0NrpUbvWZbxKfIRwFq7WoCtYHMp8EL6xc/J9gLQFXNGOypsb5nnC3lw6yPNBJxwtRYHuTLNW/+NLhmGnucGH7jV8GRVcOMHR4LzXiBtpFkDfYc24PJJ9bMN7Z9m0Bw4UUXccstt3DZZZcVf6dr1qxhenqa3bt388ADD7Bt2zYAHnroIdI05aKLLuLee+/lwIEDHDx4kE2bNrFnzx5KpRKVSoUsy0iSzumdrhGA4DwAXz78siuaDgTaxOjhcYZXDLnaqEAbaYpAjPUGzD4amGWFGCRN3W2WQard9A5tjuu09c0Yyk/FiEHHAlNyNjKmpLAlhX21SKBUCHFc/jNvEDHaRwRzEejsWmRikWm+ueaP5jQSv4sWUepm80q/zW20KERgqydgSx1hsZ/I1f9RMVSqCcurM6wvjbEpnqEqTm5GasNChiTRCptJt+7M+lFxLTOUi1GFrVeyk0NKydDyQUYPj5/0zwQCJ8Jay+4ju4uI2FJgYGCAj33sY/zH//gfefTRR/noRz9KmqZ86UtfotFo8OM//uPs3buX3//93+cnfuInWLVqFR//+Mf5+7//e/6v/+v/4rbbbmPLli0dW3931QAaw+6juzu9jMASY/zIBL0DPcSlOHiatZ1c5VjvzCK8WbSPxOW1clA0JqCkS/+2XAd846+vBcy7jC3aexBqLd00DK2w2o18y+sMrTFgpRNhxQ6bKWrhI3NCZa4eMJGoyGCTpmcfMrdqadmHdGlpqXDNK5F1ViuZBO3q7lwa29cfmtx8udmJnO/bKlf/Z0oWWc7oqzRYWZliQ2mUlcqedNJ21gqqVpJqBakXgDoXr6bwJpw7qvDUntG4HNM70MN4aAAJtJndR3ajrT7xA9807f6w/+r7E0Jw/fXX85a3vGXOB7jf+q3fKr7+jd/4jTnp4e3bt/PpT3+6+PlONsR0jQC0WFKdsu/Yvk4vJbDEmJqYJoojKj3lIADnhdzHxQDSubIATuFp94V2NXRoWZgnF4KtNVKmKGxiRGFi7AyatVHeCqZlekjeJIK/qOTiB5oiyDRr9dzsYIlMJTISrjNYghUWGbV4FYqW9USuJrEpQG0xAs7/5n79+cLxU0dES1rbRTVtyVIqaQZKdUaiGUZUnYqQJ7wIWGtJsbyc9tCjSzQaMaImkQ1QDYtMLCIzTZuc1nTwKVLpLaMixfQpTc8JBE7M3mN7yfRCWcEsjLB6NRH3el93WvS10jUCEAv1tM7hicOdXklgiVGbrmG0oW+wN4y1mjdaRaCb4uHkm0Fo4exSlCk6eV3ziJ0bnWoVXW6amU+zWoQR3qDZiUBr8i5c12LrjmXd448Tgdb6KKCWTgCmChFpJ/iUQPmOYCMs+dg7K3ATSaxFG2cQLWKB0NJHH/Nj4x1LratFlKKoS7TK1zLmtX8lCyVDuZwyUKozHM0wKDPkSY7GOphZnquvYJMuYWoRalYQ1XIBqCF1kc7muc3P76mJwP7BXnSmqc3UTunnAoETcXjiMI20UUTE5o1Tq3o4uf0tQbpGABprmKpNMVmb7PRSAkuMNMmoz9bpH+rr9FKWOLkI9PVnBoTwaVjTkp5srVWjmXW1iGbThfL6RVgXWfNziYWRCOMEmLR2TtpXgGv8gLmRr1d062pkJLHK+Jo+p9nyiF1eTphP7SCyznnG5ALQIo1PRReHsK45REm/flH8Hs3OZossG3pKCYNxjSE1S58wiBMIQGstE0bzVGOYnbOruDGLkHVBNAtRzaIaBpFoRJa5esciLf7GroL9w/3UZurBOD3QdiZmJ5iqTbGsfxmyu1oQTku6QgDmLdQTMxPMNmaJqHZ6SYElhM400xOzDIwEb8n55bgmjPzW1wMeLwQLGz/Lq3Te+m9J4efBiRaTE0VzQG/ei+HNjzM3E/gVQtDSMrtXQyoRkUSmBhMpZOSnzBmLtaKoScx3oRE+5Syba7XWmT/nI+ikgEhiSxGmrNBlN6VDl8GUwZYtpVJGX5wwENXoUw3iEwRBrLXMWMNjjT4emtnESxPLyDKFqgniGYhqBlXXyCTzHci+CznvtHwDInBgpJ/piRm0XjrF+oHuYKY+w8TsxPx3AYcI4EnRFQIQXAPIkYkj6EQTL1DuPnD6MDU+Rf9Qb6eXsQQ4tb9Nayk6ZF+xFRHA/N1atETeKKaXWeUMm4tjW5xC9F/KXPwJvEG0r7Exxqek/Q+1RAFREpkqbGSQmcBoZ0xtI+9GXUQEbbFv7YWqttKLVouRwqW2jXUpYyUxJYUuSXRJkHkBqEsWyoZKOaU/rjMY1egVCdFrpMGsdfWFk0bzVNLDA9ObeXp8NWPjfdhUEs1CPG2JZg2yniESb7+jj0sBvwEGhvqYGgulEoE2YwRZqjk6cbSwgpm/NHDQECdDVwjA8cMTZGlG/SnNmq9vRaYhNBxoL1Nj02w6e0MxozFwqojmrTj+PiAfEfcK3P1uPJsXZMa0WJa4hwjjun5tvn+JE1+06Bhvytw0j1bF/dJ/T4isac+ijbOBae2GLaKABptpZOo8BmXm5xD7BhaT1yLixKeb1y5aIgsSRIRUBpGaIgJolUBXFLoiySpe/FXAVCxRJaO33GCwVGNQ1eiRKdGreP9ZazHAUZ3xdNLPI7MbeXJiLYdGB1HjMTIVRDVLPGOIahmynjm/xcxHAc0bj/4JKegd7OXQ3qOn9HOBwIlY/vg67DOG+q2aiZVTlEoxQysH5+dglvY2gSzRS0ZXCMCoFGGMZXzvJOWJkP4NtJ/pyVkqvRVUJMnShbAhWCr4N9GWDtfi33NoaTh4TSGYR/58JM5aBNbP4GXOBA4rbDMKCIWXnveT8SPQwAqFla6bV0qJVBKhJKTSiaEsrx9sUYG+K1ho4y1lch89n+bNSxnzWkAl0L7jF9FybOk6iWXsUsDO7FmQVSRZVZD1CLIe0FULPZpqNWGoXGMknmVIzdIjNPK4t2BrLQ2rOaItTyfDPD67jmcmV3NgbJBsrERlUiIzS1S3RLPaR//SIvo31wbm1K9aSimqvZXQARxoKwJBPFsGYHzPJEopotI8y48lKtraSVcIwEpvBQSMHhrr9FICS5TZyVnKlRJRHAcBeNIUfiz+n9JrP9H8NjTr8XyjhhWv0n1qoVSKWbF+BevP3sCaM1az9cLNDA72cufNF3PGltXsnhznhclR9tcnqYnMCTBlscJFpqzCRQaFrw0U7lj5LFwlXCgwt1koImtat9Qi4rwDdbMjWWTGNXcY322cLzmvRRS4g0o3e1fJPFUtkLEb9yas+9pEoMuC1Iu/rAdMjyGupgxU6iwrzzASTTMka1SFdelrKKLS0zZjbyZ4MVnGE7PreXZyFfvHBklGK8TjitIUiBRU3RDNpohaAo1m9M9q7fZl3lgRVFyOiMsxs1Ozp/yzgcDJMHpojHK1RKW3PH8HWeTir1arcfToUdauXYuUJ7aJeqN0hQBUyv2C48dCB3BgfqjXGkgliUsR9XBtOwlaxJ8XVchcDLrv5TZ9PlFbiCxhRSG2EIJlq0a48q2XcMXNF7NszQgz03WOHpkgkhJrLbGUbFm/kqtXbqW3v8Kh6SnuefEFvrNrJ4fr0054CQsStDeJzpdni4icN3VWAimFb87w686k747VtNYRuhFuTizNmQJiW/afp6J9Slgqnxr2Ys9N4hC+VtHVLupKU/zpHoPoyejtaTBSmWFFaZpl0TQDMqEiBBLhU76WGZOyX0t2JsvYUV/N89MrODAxQH28QjShiCchnrFIjWv8qOXRvxSbtUYA33gFfFyKkVLSqDXe+EsnEHgdJo5NurINOc+lXotYBM7MzPB7v/d7lEol3vnOd3LllVfS09PTdiHYFQIQwGjD9Ph0p5cRWKI0aglYKFfLTIXX2Qnw6kcKF/UrxJRszt5tqQWcM4fWGKw1YKG3r5db3vsWbvzhq5kcn+aBbzzCUw8/z7HRaVIruPC68zj7gs185asP8vBLexHDZUbWDnDBuRu56cJtvPPiC/jqs0/ytzueZKrRcBYt3quPIg3rm0S8CEQJlI8ISimQQrj1p4AWTdsYQbFe4ZtShO8CFl5hun1bTOSOI4yrE5QR2MjNEBZaIL1wbApAyKqgew30aiq9CcPVGivK06yMJxlRM/RLQ0Uo39sMMybliLHszQbY1VjOrpllHJzqpzZZQU0p4mmIpyxxzTixmmpEoyn+CvuXN1j7l1Opll0aOhimB+aJybEpzGLrMF/gxtRly5bx2c9+lmeffZbPfe5zfOpTn+Kuu+7irrvuYtmyZW0Tgl0hAIV0b9LhwhyYL9IkRWtNpWce0w5LCXGc+JPeLE9JJwRFUwC2jl1DuFFwZ2xbz4c+8W5KlRJ/+Z+/zGP/9BSNeupm98YxolQq6gDJLCSGZCZhz/5jvDgxyt89+zSXn72Z9195KVdu3swfPnAPO0ePuA7hPO3bGqVrFYVColrKFGW+VKG9FY2ds+7cl9CJPx/Ny/ftJ4FYZX1Hs/P1kxHIGGcQnTvO+MfqMuiqwfQayr0JQz01llemWVWeZGU0yYis0ycksXBvvxmGSWM4onvZlw6ztz7MgZkBpqeqyMmIeFJQmoTStCWuG8iM6/pNEkhaUr9vMvoHUO4pozMTPAAD88bU+LSr1Z3P2eyLvAnEGMOOHTv48pe/zMTEBB/84AepVqt8+tOf5nd/93eXlgAE9wvPTgfn+cD8YLQhTTLK1VKnl9LltKR9c/GnIif8pATlhWCRCqaZ+vX+c5dcfQ4f+vl38dh9T/PX//WrTIxOuTdQKYpoW7NZAYQ2yNS48WypQCVQn0n4ztM7efTAXu6+5ip+65Y7+Y8PfIf79+zydXkWU4xdy5feFIXOzbl5v8y7bbV29X8t63f+fu5WuMEiPgpofb2hxUbugdY/1kZgMtFsYCEXgBZdttiqIaqm9FYbDFVqLCvNMKJmGJSu+SMWMQLIrKFmM8ZtzOGsn4PJIIdr/UzOVDAzEfGMIJpxhs9RzaAaXqimue1LnvptpuDfzNWqUi2TNtLgARiYN2ana8GJ4QQcOnSIP//zP+ftb387v/iLv0i1WiXLMlauXNnW43SNAEyTzNUDleP5P5iFLM3Ci/A0whhD0khCBPCE5J56LZE/JRFKOfGXb7JFAPrOXqEMF12xjbt//of5+ue/y9f+13dIG0mx2yKElncB+zFuZBqZGlRiMLGrrVOR8+Abn5jlP91zD++9+CI+cc3N/N/mm3x/78tO4igvAluWTssnY4ts3pdbxWQCkYfs8m7mfKKIt6URrRoqt6RRttmFbF29oIiaghFaIoUVg6pkVKoJA+U6w6VZhuNZBtUsfTKlLCwKgcHSsBnT1jCm+ziS9XOk0cd4vUpSKyFnJVGtRfzVNDJxEUyrtWv8aMPkj1YqPWWSRuL2FzitiErRgsyotcaSNtJ5P85ixhjDNddcww033IAQgnvvvZehoSHe9ra3tfU4XSMAe/t7+MTv/yxpsgAvDAt//V+/yg++9ej8HyvQFRhtSBsp5WoQgK9NS5OHTwG7yJ+CSIGK/K1sRgGhEICbNq/iwx9/J1//6/v4hy98D60NQspibi+4blc3y9dNrBAW14WbuPFsKnKj2dzm0rqZ0Hz+kUdBCH7hmhv55D9+ledHj/j1WkxrV7LATwbO78rHebjpIaIlailaPQ1tMwLYKuqApgWNsszZnY8GFk0jykJkkeWMcjWlr5IwWK4zFNcYVLP0yzpVoYm9IE2tpmYNk0Yxqns5mvYz2uhlplbGziqiWnPcm5v4kTnPQWNcJDPz0cw5xs9vTgCWq2WSRoox4cPx6cSazav4mU/++IIEYErlEj3982z39ub/FDrG0aNH+frXv873v/99KpUKAN/4xjf40R/90bYfq2sE4MSxSb78ua/Ne/eZEIJ3fORtrNm8al6PE+g+knpKuRJSwK+LoCX6J4u6v0L8RQqbp4GlbwM2lp5qDx/86Nt5+rGX+MbfPICB5oi0fKQHFI0XGOFEoLWIzI0ys5FEKYFVytfy+QUB2hi++NCjbBgY4mNXXM9vfv0rzGZJUa9nlDuEMEAJtK/lc5ssRJr0UTyh3fjJOVHDvJnFNFO7IvcmLC4m/mek73SWzBGAIjKoyBArTSw1sdBEQiOwaCSJFdSsAZOQWhgzkiO6l0PpAEca/T76FyNrLvqn6s7zTzZc3Z/I6ya1aVvjRyvlaokkNICcdgwtG2T52mX85f/vS9Tn+Rpc6alwxvZNrJjvD+OLVADOzMywb98+6vU6O3bsQAjBtddeywUXXND2Y3WNAJwan+aBr/+ApD6/EUAhBNfdeeW8HiPQnSSNhFIQgK9Di/VLqwhUPuoXKWwUuXm3qhkBFNZy/dsupnegh7/6/75DaixIVzNorUEYMceH2VqD0MKJFwCtEUmG9Pu0vvs4XxFWIDRoo/mz7z3A77znXdy+5Vz++snHC+2F9+wzET5kl3dy5PjQnRAIBFI3o2Y2L0a3rhNY5sJPM8eges5EklwItpw6ERlkZFDKEClDLA3KTzPRSFKrqLviQVJhqNmIo7qHg9kAh5MBjjZ6ma6VsTVFVBeoBkQNi2oYZKIRSVPwWZ/2tXlNZZuudnG5RNIIAvB0pFFLeOjbjzEzzx6Q5WqJn/z1D7Ji7bJ5PEqbU9kLJCattfT09PALv/AL7Nu3j3K5KZLNPJRldI0ATEPaITDPhBTw6yEK/Qc0O33zKKCULvIXSWykvPWKe/Bwfw83v+0yvvyF7zE+MevEovYRQpPXCuaijGbHcJ62zDSkGcLbtkQSwHuvABjQRoCB0WMzfPHBR3nvFRfznR07GavXijXnxs3GdwAK70moC63magIVvoEjc00otmgTztPAFqFF0eHr/u2FoqRFCTbPF9KCtAhhkcL6sXZgrCCzioaJmDFlSiKjJjQRhmlb4nA2wIFkiMONfsZrVRq1GFmXqDpua7jon0y0a/ywpiWK2jrxo00CsBQxMxmmgATmD6Pt/H/IaHcX8ALyjW98g/PPP58/+7M/I0nceRJC8M//+T9n69atbT1W1wjARj1xn2YDgXkiTTJ6B3vnZCQDx9NSF1fU1omi6cP6ebdW5l0VcPHlW0nTjId/sBObN5C0GEbPxbq6OennAoMTMmlW/JwU7o1JeBEoNEjtDJd1Zrn/yRd498UXcc3aM/j7Z58udGLrr9CMBuIjgvn3JFYIVCoQygm7fLwbRSQQpBeBMnN+f1YJJBZjvYJs/dX868kKgRGCTEuSLKKuDFNpmVhmLgVsJbOmRCQMEsuUqXAk7edwo5/DtT6mZsvYWoSqCaJ6Hv2zyFQjUu0nmrQ0e7RZ/AkBURyRBguYwDxirSVpLLLX2AJdL4QQfOADH8Bay2/8xm/Q39/Pc889hxCCLVu2tP14XSMAs4Vo/gic1mSZJoqc+a4NCvBVeA3x15ISLlK0flNKcuVVZ/PgD3YwU0+cdcycRpKWfQFY12m65cIzuOLmi+gf7OXKG87HGMMLO/ZTb6SFAMNYhI6QmURq6aduQC2r88DTL3LDWVv41hPPkQpdmELnv4aVYCPXaVuMDvE6UAmwUqGUQGTN10EeMBDWRf5kBsYf06bC6VZasssifzDufGiJAbSARFqkjFCyjBQWYyWJiZhWFaRwr77prMKxpJdj9V7GZ3pIZ5qdv8rX/6mkJfqXafe6tRZrbFtr//ITpyIVRiUG5hWLnf/rfWHltPgQQnDgwAH+4i/+gve///186lOfIooiPvWpT7Fp06a2Hqt7BGCmgy1LYF4xmUZFqtPLWES8SgrluLuGhvpYu2aEL/zv777OfpoRq6EVA9zy3rdQKpeYnZylUU+YmZjhgku3sO2CM/jWV3/A+FStsGUR2iK0clsmkZlApPDY07u49cJzWBZVOVKbxig3K9i2ROasAJTAxtY1pTTz287bL5VI1bR+mSMi847gXAAqF+FzEUyBKEbEeWGZdwNbiRaAaL7OjBUkWjEbxVRU1e9eMJOVGG9UmaqVqc2UYVahZoWzfqn72r+Gj/5lPgKYz1nOG1ba+UFGgIokOgsCMDCPWGfDFnhtarUaWZbxgx/8gB/5kR9hamqKPXv2tF0AzvMwvpMnfOoMzDdaGzd/cnGWhiwAtqknWsVFy8SMfGpG/u81q4bJ0oxDB0aL+4rH2xaxApQqJW5+93VMjU3zpT/9O5584FmSesKTDzzDl/7ff2BmfJobb7+UkgQaCbKRImspajYjms2IZzTRrKE0azi8ZwyTajb2DhXRMplYZNbSvAE+HSwwsUCXQJcFWQWyikBXBLoiMWWBLrnH5GPl8tPhmkFEIQRF5v4tMpCpQKSi5T4BqYBEoRsRSSNitl5molZhtNbD4Vo/B2YH2D8zyL7pQQ5O9zM61cPMdAU7HRHNSKLZluhfw9njzBGARcNHa1dKexC4+azzUWweCORYa8nCh4zXZdWqVezfv5+/+Zu/4eqrr2ZiYoIVK1a0/ThdEwE0hZFpIDA/WGPmd/zQkqCle9YeL+ZaxJ9Po69aMcj4+Az12QbCGBe5a91oCsHNZ2+g2lvhH/7Ht5idnPX+gGC1YWZimnu/cj/v/j/ezsaNK3j+2b1uTq8XPjKLEGmESBWmLEltncnxWdb29vNkzWJKwnlLRxYbi8JGJr8Vhb2NHyPnvQZzwSh9BM9FAd1EEZGnkQxILYqckrV5zaBP/xq3b+tzxNYARmK0IM0MOpMkKkIpg5QWawXGCLJUoesKUVeoaUk0A/EsxDVDVHfRP5m6Bpl8gon1T1EhrttayiCQUgYT6MC8M9/1/nmj/mKlt7eXf//v/z3T09P09vbyvve9b2kLwJD+Dcw31lqEEKEH5FVpEX7grFqsbHabaouQ2nfMCoS0IAWDfVWmJmawSea96VqmfHixmP9tb9iylj3P7/NdpsdFsoxhemyKfS/sZ+OZq3n+yV1F1FEYg9AGqw1CRwitwMDMRI2VPX1ENYvWgBaIEhhrMZFr1sijefkUD+PTv0aBVKIpADXNgKfATfWQHNdImHd7NL/O64ystd4vsOgIcf0aRqG1REtLpgxCgDUCawQkEtEQqLqL/BWmz63pXz/rl8xZwMzxLGz3q7ilWTsQmE+kmudSnHb/aSzw30Sj0eAzn/kML774IkK4D2a/9mu/xrnnntvW43SNAMSGsvzA/BJeXyfiuOidcXYtwk+eKEyiLcWs4FgIdJJBooto3ZzxZD6yL3D+X2OHRmnJM7v/e1sYgaQ+U2PNikGEMRhjfMTR+HpA47cIqy2mkbGizwnA3LRZG8h9AC0CI5p1gdZvQgmEn9trMhfdM768rhCBXjwWU0kkWN/wUYyEo/XWCT+XehZNfWvAavd9K6RbiwZhBCIRqLpA1b34m7VENYuqG2QjQyb5uLfMmWYb7c2183M3P6/o8GE8MJ8IISiV51t6iDaLtoXNHB04cACtNX/8x3+M8mI5itp/zrpHAIbCrMA8E15hJ4HNo1m58BJe/LV45Rnru4AlSa1BKVJIrTFZS63acVMqrDHMTMwwtHyweaDimLaobevt7+Ho/mPoRuLHyBkwCqE16MiZRmuNNJaSEBzZd4xoNnNNIkYirOvxzhAY4SK+KDCS5hg3AOVEmIzAajfbNzd8dgI3F4B5JNEW9zkxaedawbSQm0e7zml3M7fD2HkMykQUfn/xrCWuWVTNoOraN39k0FL/54yf89Ej88dCzIMNnL5Ya6nPzu+0kbb7AC7wZ6KhoSGyLGP37t309vYihGD58uVzjKHbQdcIQKlEsOcIzCtCCBdt6vRCupm8tsxYrHATO6zQLTN0/WO8zcvEkQkGL92CMgbja9XyerVWs2JrLS89s5ub3nUNIyuHGD081npQwDKycpC1m1bxrS9+b454dLODbTMaaC1RpBjoqzJ+cBxVywo3llZTwMynbA3CibCWKB4SZzAtfUSwZQawyLPhXvAZZV0UMAKrbFMEHt9CV6zBfSlwx8BNHS6Cdrm/oEr81vBbYlGJRSTGN35khfCb01wzX1hXmxUEYCDQWZIkYXR0lM985jOUSiWklPzCL/wC27Zta+txukgAqhCiCcwrUoUOx9enWQRnc+GFF4FkhTULRhYC8NDLhxkY7KGnEjMxPQva+HSlKWb95kJu7/P7OPDyIW5+31v4zl9/D+kbcqQUrFi7jBvffS37X9zPvhf2OwEp3TSPPCLp9uMaTXqH+hjor3J49xFk3VtKWOtUmg/NWaxPvVqE9E0aLVYxuYATxs4Z+ZZ3gOQi0ORp4FwIKh8NbHm/yiOH1rrIYuFD1pLtFla4hpLUNZ/IxG0qscjUdzEn2hs/Z5D51Ls2c0XgvKV//bkOjVKBeUaqrjEg6UpWrlzJZz/7WZ5//nnOOOMMtNYMDAy0/ThdIwBVeEEE5hkpJUabUAx4InwU0BqLt1JuCjBpEC0C8OCug1hjWbtuhPGDx3zDSFOwtAoXnWXc87f38ZY7r+KHfuJ2evt7qPZVufbtV1GbqbFn5z6+99XvozMv6LQ3nS7qEg3CKKyxrFs/gsk0h3cdQjQS5BxblMgLON/129L9mwu3oo6vxcMv7/gVeW1i/jgf9ZsTAcw7gItT5sSdMGCxxfxj4XckLK72zxtMy8yZUMvUCUKVWmRqEJnbXDONbomi5q/b+XvxWpxVUngvDswnQoiF8WNdxO/z9Xqd3/7t32bHjh3863/9r7n//vt5+9vf3vZpIF0jAONSFFIPgXlFxQqdhQjg6+PfNf24NmtkUwSCE3WF+BFMHZtg13N7uPjqc3j6+8+5lKXNxd8r05b1mTrf/KvvsnrjSq5/5zUIAUcPHOPer9zPoT1HnEBvxeB7KgzCOmkmBFxy9Tm8+Owepo9NgFJFVrc5fSTy97j3lMznYHP3CZN3CLc0dFhwBs/5WfDfL5pBpC0EYVH/V/xqebSR5gQ8//08/StoiTBa7zFY1Fv6r42lGPeWi27feWzndCDPAzaYpQfmn3zk4Lweo91/JwssJg8cOMDQ0BA/9EM/BLiawIMHD7ZdAHbNR724FBP0X2A+iaIInWWhzvSEeNHhxYiL4mmszrBaY7PM1adlGbqRcv/XHuLiq89lcLDHpX11Swdwq3Gxx2jD/pcO8twjzzM7VePZh3dyYNehV4q/oo3W+JSyBW0YGu7jwqvO4f6vPYRuJM4nL0kRjRRZT5F1japnqLop5umqhk+5ps6wWeZm0aZlaXmdoMTN+/U1g1a2iD/ZouSE9V/ndYVNYfiqrzF73L9t8/gir60sTleLeJ7nyF9zSc6gd74vzoHTHCEoleP5P4xt4zbvq53LwMAAhw4d4ujRoxw8eJCHH36YtWvXtv043SMAyzFBAQbmk7gUkabZok4NLBwtItBYrLagbUuTRy4IM5584Blmp2Z5yx2XNyN/ba1X8/vygvL6O69kamyap7//LGQZNk0hSaFxvAjUqLrxUzWaItDV3ImiFi+fHFJsxy1b+Pq91uhd87bl30Y008jF44/baIkE0vz6tTneb2YesW5EV1wKAjAwfwgh3PV+Plnk7/HLli3jPe95D0899RT/83/+T2688UY2b97c9uN0zV96qVxCSUmYEBiYL+JyTNoIr7CTx7bcOF+9YkQGTVuY2sQsX/3v/8iP/vMf5uF7HmffC/tb0r7teid2+1l/1mpuete1/H9/8EVq07Mgpe+xFUVdokAgjxNMAumEnAFthJsxHOFHv7mP+LZFazW7gN3UEGdILbDGFpNCWk2ZC+FnxCsbSmxTWBbNInmKWILNZxNLX/PoLXaQ0jWvSGfILYRgvj8kp0k2/xfnwGmNlJK4tACvsXaKwAUWlIcOHSJNU/7bf/tvADz88MPs3LmTs88+u63H6RoBWO2tsGHrOmana/N6HCEElZ7KvB4j0J2UyiVmp2Y7vYxFRotisa3CT8x5xEPfepTLbriAD/7ie/jDX/9TJ87aTE9/lR/7xHvZ8ejzPPKdx91kEAu2+NhoW+JltkhvFBE3I5wHnwGTCUzsR8cV/n6iKf5E3gSSd/4KZ+isfJ1gqwdgqwD0xzm+C7gZDRTFopwxdVP8odxmvfBDSS8EhbMwEq3nfn6EYFJP6B/um5d9B7qbKFKs3ryK2jxfg3v7e6j2zvM1uB2Jhw4xOTnJAw88wL333suyZcuw1vKVr3yFt7/97W0/VtcIwOVrRvil//vnyNL5j9BEpYh/+rvvz/txAt2DEFCqxDRqSaeXskixx/1z7rtr2kj4n3/wRT7xHz7KB37h3fyP//vzNOrtO9flapkPfuK99A708Ce//d9JGwkI6V3+nAjMXUSbIlD47mB8CtmZRUsNugQmBROJZpPHcZM+cmHoxJkTiqalk7hVg80RgLn4K05Xa7twyy/lj5vbzBglkJHERhIbKTdZRTkTbKv8kOF5jgAm9YRSuTSvxwh0H7XZOlJJfvHTPzPvk2CiUsTIquF5PUbb/0oWUEweOnSIb33rW+zatYsvfvGLAGzcuJELLrig7cfqGgE4O13jP/7an3D0wLF5P5a1MDk6Oe/HCXQPQkpK5Zh6bZ4d6Jc8r/1OeOzgMf7rb/85H/t3P8WHf+Uu/ucffJGZyTcfCewd6OXHPvFezrrgDP7wX/8po4dGIR9am9uuCINFIIR2t/5nBRbpBaDQFqkVOpPIVGAi4SKASrREAfPIn2gRgbY5Du64aGHrKRGvEnUoUsktUUW/sMJmxionRE0sMKlExAqbKYSOnB2MUi4FLY2LDB7fZtxG6rMNSpXYeWa+oiknsFR5+bk9fPIjv7cgFkAr1i3nd//3b857I8hCz+9tF1u3buUzn/kMY2Nj1Ot1tHZG/PPhktI1AjCKIqYnZjh6YLTTSwksQaSSxOUSjfkeQXSa8/Jze/jDf/2n/LN/+2F+/nd/mv/x/3yBPTv3vaGoghCCTWev54OfeB/lapk//Nd/yp6d+/x3W1LTBiwSYbUTg9aLwsI70CKNwerI+eylChtLTCRdBFDl9Xc0RV/hIzhX+DUfd1xrYGvJY14a2Goh40UmsuXHpEv/5kI0F4Eyk9hUYSODiBRohTAGa1QzAlikgudBAJZLSOnmIwdOD6yxjB0eX5Bj9fT3EMXzbDXUzjFwwEL3ATcaDX7rt34Lay1R5Czyfv7nf56tW7e29ThdIQCt97vq6a92eimBJYpSirgUhQjgArB7x14++8t/xF0f+2H+xWd/jnu//ADf+dL3OHpg9KSEoJCC5WuWcdO7r+O6O6/iyQee4fP/6W8YPzrxKo9udgjnkb856WBvoyKsRWiDzZwItLFEKp9ulcILNNGM1EnX7NIq+nLhZ33jhltscxnFilqEpBOYeIEHQok56WOrXGbXRLiaRC0wmUSUlKtxzKOA/ncUyivIvCHEtlcENmoN4lLkJjOlQQEG2k/vQI93OJrnsYOLeBbw4cOHWbduHb/+678+r+eoKwRgfnL7BkPxcWB+iMsurdUIAnBBGDs8zv/77/6CC689jzvvfivXveNKnn5wB4/c8zgv79jL1Pi0SzcJNwWo2luhf6iPTWdv4JIbLuTcy7dxdP8xPve7/x+P3/c0Ons9MWK82sp7lU0xhcONkcNPKFEIbRCZchE2JUHJQvyRR/zyZhB/XyH4WqOEeQTuuPfm1u5ho7yoiyjGw7lpKr6z2DeBGGURkUDH3pKmJBFaInTkRaDy4k+5RpFc/ElRNJy06wpV97VgpXJM0sYazkAgp2+wt+kQNV8s4iYQgOHhYfbv3883v/lNBgcHEUKwbdu2to+D6w4BiEvRDYz0d3oZgSVKueIK20MTyMKRpZqHv/M4Tz7wLGdffBZXvvUy7vrn76LSU6E2U6NSLbNs1Qgf+bUP0GgkVHur1KZr7HjsBf70U3/OjsdePAURYlrSwX6GMH6esXEj5NAK8sYKpVw0TckW8ecFX17fJ/N/e/FXRN5o6cj1+O9Z4dO9SrgUc+YaTtzFSKABIicCAScWrY8ERrg6wAxMphCZRWQKsgihnYB1PyeKmiAr2isAG7UEsUBGvYHTk4HhftQimze90PWExhhWr17Nd7/7XZRSCCFYvnz50hSAWZphtGVo+WCnlxJYolR6yuhMkybBB3ChSeoJT9z/DE888AzV3irLV4+wfM0IF157Huu3ruPhex7nifuf4eiBYxw7OEptpv4G9Yz1+VSJlbiUb6GurPfy8xNKtJ7jtVcIQC+ucpEnWoRhU+S1pH9b/p2LRasENpLIyKJN3gHiVyiEG/4hvAi0NGsBlUBEFhOD1sJFATOFynyOWBtE3oDi7WGcLyNtSwWnSYrONJX5tukInLYMrxhCa0OWaUrz2HSyuCRmk1qthjGGj370o8V9QggGB9uvj7pCANZnGiSNlJGVQ3NGKIlF+xQGuo3egV4atWRBbIYCr4GF2nSNPc/vY8/z+7DArT9yA4/e+yRP3Pd0+w5iDZg8OuabQ6xB+NnGufgTUrakU2WLmHOiqmm83BR/COEflkcA8++BFV6U+dpCE6u8A8TvFz972KeV8/s4rhs4AhGDySQyVhhtkNo3hOT1g94sWhjrtd+rFCO+AdIkI2mk9Pb3vKn9BAKttF7Xh1cNkdQSBPMcaV6kKeDvfe97/NEf/dGc+6SU/OZv/ibnn39+W4/VFQKw0ltBlgTVCyMOXv8i5SO9DD+7qtPLCiwh+gZ7mZ2uBWuL04Lc+w8QBmsFwropHojcSkX6ur5mU4VoFXrQFIe8xn2t90uByAVgpCBSSG1brGFUkUbOO4yNsC12M74b2Qf7hPbp4JJEaIXNXO2iO6RASImQCit9zSPCz11+c5FAYwy16Rq9g71veB+BwKsxdu5BGstnqZ4XURkoUy6V5+1Yi9UCBuCWW27h5ptvfsX9UrY/WtoVAjAuR6AsQ2sGaKydgTRE/gLtpX+ol+mJ6Xk3OQ10C/kYOyeKrMmjdwKbj7MTwo9Ywz1mzqQN5nr9HScExfH3FaliP7Ytn4WcZ5b9mDeVi7088hf51K/N1+ANp5WLBJrIm0PHCptFfp9+QoiSCCNddMXKvOuFNyMArbFMT8zQPxQa8gLtpTE8S2PdDENrBihVS0RqfuVHW0XgAl425kPovRZdIQDBWz/0L5/3F0XgNES4wuP9uw52eiWBBcU2b5wnjIuUzUnx0pzUMSeyV/yv+Ldouc++Qig6pSf83F6M9yFEuJF0QqAkIFXRSYyvB5T5nGW/S1dDaLFZ3hQiEZkXgcYWKWuh/NdYhM2jgPni3vgVa2psmpXrl7/hnw8EXotYxSwfWD5vxsYF4XP+SdEVaksIgUQy2DtIX7WPGqFOK9A+okjRM9DDxOhUp5cS6AgtptH57Rzh5/9XfNl6f47gFbZic6KDTvxZLwCd/6Atdi2laLGVydPO7psGENLOnRIi89FwTgSKzKeCjWsecZYwqhCahe0NrgmmGQk89SvhxOgkZ5y3CRWpE9jvBAKnRn+1n/5qP1IsQJQriMAT0hUCEJwI7K/2M9gzSI35HwcXOH2IyyUq1TJT49OdXkqgo7SM6yiiZKKIDuZdGUXB+nEC8FXvE+4nEMJ3HBsEqjkQROZdxQLp6/2UxKVx/VKEdWKP1muicDWBRoGIBCKWCG2x1qWqrVIQx027m+Zv41PCpkX/ndqVcGp8mkpPmbgUBwEYaCtDvUP0V/rnv8Gz3T6AS1RMdpUALEUlVg2u4mAQgIE20tNXRUjBzORMp5cS6Brs3NuiJde+8iFzeGWa2P2ocM0lVrhonNeToogOegFILvTE3H1aP5M4rw1siQKKGGcJY6yrZcwbTWJnHjhH/AkfU7QSa4zfd974dHJXsZmJGaSU9PRXqc/WT+pnAoGTYfXQakpxaX7Tv9B2eblUuxK6RgCCqw9Yt2wdj9EuS4hAAAaG+0jqSTCBDpyAkxFIrQKxRTBaUdQXzhVkomgYEUIgc1NpNFa4SGFu42Lw3oBeJ7pRcr5fpSQQVmKMH10XK2wpnrNvK5x3IEJjjRsgb00+JcW+cv2vQb3WIE1S+of6GD00dnKnLhA4CdaOrCWSCyM7lqpoayddJQCllGxeubnTywgsMYZXDjE9MUMWTKADbeU4MZUH3PJxdAKE9g0iWVakg4Vw3cBO6DlvP+HChRhlW0bOeYPoSPhxIRJtndWMjRW2HHvxJ0F4X8NMY6UXglq7Yxjr08I+NXwCEZgmGdMTswyvGOTl5/bMx4kLnKZsXrl5QbtcA69PdwlAIdm4fGN4gQTayvDKIcaOjAcLmMA80mI7k4+jA0AXDRo5ube0LL5wbcFWOn/AIg3sRaARzeo+jXQWMSWJqUR+eIlPP+fm0JkAkfmIoMAK7QSpgaLm8XVEoDWW8SPjjKwcbt/pCZz2SCnZtGLTwjWAhBrAE9I1AtClRyTrl62nFJU6vZzAEkEpyfCKIZ5+8LlOLyWw5MmbSnwBoLFefDnvv7wZpGgKydPBMjeCdv820sUQc7sYa0UxKSRDYBXoiiLrjZCxRCYamShEEiHSDFIFmUKkGTbzIhCNEF4EGnNCEXjs0BjbLjoLqWQwTw+0hXJUZt2ydUgh570GEFiyoq2ddI0ABPcJYcXgCgZ7wkzgQHsoVUv09vcwdni800sJnBb4q44BK403ajYIrefMFi7EoG8OsUpgM4lR4PLDvhFE4YJ/CowRZMIJwKwsSHsVKpZOBMYKGedC0G3FuLssAwRWZ02vaF5fBI4eGqdvsJdSpUR9JjSCBN48g71DLO9fvjAZvgUUf8YYZmZmiOOYcrk8R9xaa0mShCRJ6O3tRUqJtRatNbOzs8RxTKVSWRhB/Cp0lQAUQjDQM8CqoVUcJni2Bd48/UP9CCGYHAuvp8BC0SIC83pA7fwFX9EZrGRzdnCE8/3LL17Sm0Kr5n4zbxStK4KkT6BSgUoEMpGohttkJBFKetsZUUwIEXi/QOu7iV9HAE6OTiKVpH+wNwjAQFtYM7ya/p7+hRM7C5ACNsbwF3/xFzzwwANkWcYv/uIvcs455/iJQ5Zdu3bx6U9/mjiO2b59Oz/90z/NxMQEn/3sZ0mShFWrVvHxj3+cUqkzWc/uEoA4K5gzVm7mME90ejmBJcCyVcPMTs9Sn210eimB04pmTaC1OAsXoV1TiNRulFvmmjaEn/QhM4kxfpoHLgJoIjcuzqWJvfezgrRXkAwKZAYyEajEohqCqC5RdYWqKYhcBFAI0bSlsXi/QkCY15waUp+tU5uuM7JqmCP7gy1X4M1zxsozKKnS/HsAziN5HXkuYo8dO8ZXvvIV/st/+S888cQT/Mmf/An/4T/8h+Lxf/Znf8YP/dAPcfPNN/MzP/Mz3HnnnfzVX/0Vmzdv5qqrrmLdunXEcdyR3wW6TAACRDJi27qz+T5PdnopgSXAinXLOHZoLBjaBjqA77rN08ACQDfrAaVEZNrV62UGoa3bfBeIq/uz6BhsDEZZVGyxkSXrsSSDIDSoxIvAukCXLHEssJHrMlH52DvrJ4YYizDGC1PxmgIwSzWjh8dYsW45zz3y/IKetcDSQyDYtnYbSqkTP7gLsdby5b/9W1584QVWr17Ne97zHqSUHDlyhIGBAQYGBjjrrLM4cOAAWZYVou6FF17g7rvvplqtsnr1avbs2cP9999PuVzmyJEj7Ny5k89+9rMMDAx05PfqunZbKSVbNrri40DgzSCVZPnaZRzee7TTSwmctuRTOaxrCjEGtMFq42xaMrc58WcQhmKIvZVgIzAl0GWL6bHoXoONLKZXkw1r0mFDMmxJhnDboKAxIEn6JFlvhK5Gzi6mFEMUISJXG9jqN/hajmmH9x1lxZplwZUh8KZRkWTLpi0L0wGcY9u3CWDbtrO54oor2L59exEBVEphjCnq+qSc2+ASxzFpmgIUwlApxYc+9CF+9Vd/lZ6eHp57rnMNil0VARRCoKRi3eY1VHsrzEzOdnpJgUVMpadM/1AfR0MKK9BprMX6KBzGzNmE9puxCOP8+qz3iTEKbGwxFYOoaFTFIGJDqS+hNFzHWoFOFFldoesSXZaYGDdvGNykEG0RmXbRRq1BSYSRII2PAr56gdORfUe5+LrzKfeUqU3XFvBkBZYa1b4e1m5ajZJqQWoAxau/pN/4/hBsO3sbV1555Zz7165dy8zMDDt37uShhx7ivPPOw1rLd7/7Xa688kouu+wyvvnNb1IqlTh06BBnnnkm1113Hc899xznn38+o6OjDA93zm6p6z7aSSEZXjnE8BkDpD0JRgYLgsAbY3jFkPM0OzbR6aUETmtsSwTQYq0Xf3ruJrQt6v+gNQJoERVDqTelr69OKdKM9M6ybnictcPjLBuZonfZLGIkIRvSJAOWtB/SXklWlehKhClFEEcuCqh8FDA3JHyNCOD4Ufd3M7SsM+mpwOLHSEPakzByxgBDywcXNAIobPu216Kvr49f/uVf5nOf+xx79uzhox/9KFpr7r33XtI05cMf/jC1Wo0//uM/5mMf+xjLli3j7rvvxhjDH/zBH/CBD3yAM888c8HOyfF0VQQQXBSw0lum90cke37wDGvuPYvqsb5OLyuwCFm5fgUTxyZDA0igO7BNIYgwWGNcPZ5x0T98BFDYZmbWSlfzF5UzeisNRnoyyipjVXWSM/uPIoDJrMJYo4fRUg/jogdtS2RaIVNQDeG6g0sK21AIJVtSwK1dwq9cbn2mweToFKs2rODAy4cW9lwFlgSNkRkOXPciF1+1hXLv/M8ALlggI2ghBJdddhmXXXbZnPv/1b/6V8W/f+mXfmnO4/v6+viFX/iFOfd1iq6LAAJEKmL7mediYt3+WG7gtEAIwZpNqzi45zDWhNdQoNP4K5IXgdYa3yDSmgr2AtBPa7P4aSDKEkWavlLCSHmWikpZXZpkS/UwZ1cPsrXnMJt7j7G2b5L+vjqiNyPrMegK6LJAlwQmdlYz5AJQOJdpUdQAvvIiZIzh4J7DrN60ig5eowKLGCvBxJrtZ55LpBYw3rSAb/n5eMeT2V7t8Z2k6yKAAEoqzttw3sK+YAJLinK1xMiqYZ584JlOLyUQaKHpxYexc+sAjWsCwfjv4zt4lSWONX2lBstK01Rkyup4nFLpECWhGddVBlWNssyo64hGGlGrK3RZosu4msBIYAvxJ5oRQHjNCCDAgZcPceZ5mylVSjRqyQKdo8BSIlYx29dvR8mF7QAOsaMT03URQCEEUkrOXHUmQz1DnV5OYJEytHwQFUlGD411eimBgKcZAXThPVcT6ESgBd8JLI1FaGfTl0cDsSCxxMIgsVRFyoBsMCgbDKkaQ2qGgahGT5QQRxoii41yKxmBlWJu2hdaon+vzdEDo8SliKFlYTpT4I0x3DfM5lWbF24E3HywRMVk1wlAcFYwI/0jbF65udNLCSxS1mxexcSxSWanQvdioNs4Lg2sbUs3sEVkzt9PZjjjaC3QRpJZifaCTeAEYQTEQhdbJAzSFxHaopiw5cjHX39PcD2enZplcnSK1ZtWteuXD5xmnLnqTIZ7hxfWTqiNFjBLVfxBlwrAfCLIRZsv6vRSAosQIQXrzlzD/pcOYkzoIg90Gd4SBtOSBs47gTODzAwy80IwAzKB1pJERyQmwiDQCDTSX5+aotAF+KwfOvdKXpEWO8HFzWjD/pcOsv6sNYs3ehPoKBdtvohS3IEJIEEAnpCuFIDgGkEuPetS5ALXDQQWP9XeCiOrhtn34oFOLyUQOI5m+hfvCejMoTVCaycAU+tGuyWgGiDrkrQWM1arcqjeT82UOJQN8HI6zMvZAHvSYfamIxxIBhmt91Crl7CJQibCRxFtsTVT0Nbb/9kTXuD2vXiAZatHqPSWF+D8BJYSSiouOfMSIrmw9fxt9wFcoiKwK7ssckPoc9adw2DPAHWyTi8psIhYsXY5RluOHRzt9FICgVfBulysTwPnVjBkGpFqZKJRDUlUt+iaQJcFaVkxXapwOJbUdMyBZJhdjdX0ygYzusxo1suhej+jtR4atRhRl35EHKgURGabnoN+FFxRi3gCjh44hrWWFWuWsXvnvvk/PYElw1DPIGevO3vBDKBbWaqirZ10bQRQSsnKwZWcsfaMTi8lsMjYsHUdh/cdoV4L/n+BLmVOGrg5Fk6kGSLRqIZBNSyqBlEN1Iwkm44Zn67SyCIO1AfYOb2S52ZW8/zsCnZNj3BweoDp6Qp2NkLVBKoOqmGRiUsrC91iO5NHAU8iz1WfbXBk/zE2bF23YKcnsDQ4c+2ZrBhYsfDjBNst/paomOzKCCC4OsByqcwFl2/nmX/a2enlBBYJUSli3ZlreOx7Ty7ZP9rAYsc2b/I0sE8Bk2lkkmEbkmhWYiKwkXRdvEKREZMmEYem+nlhbDmx0qRakqQRaT3GTEdEU4p4GqIZiGoW1TDIxIlLMt3sOj7JKKC1lt079nL+VecSxRFZGjIygZPjgsu3Uy6VF77+L3BSdG0EEFwd4AXXbsf2GbJy6j+tBgKvzfCKIaq9FQ7sCpMLAl2Ot4GxeRNIlkGaIhoZsp4R1TLiGUNpylKahNK4IB5TiESQTJSZOtLL6JF+po720ThaxY6WiMcU8QTEk1CaMcQ1g6ppRCNz+9caq33dYSH+Tvy+uv+lg/T0VxlaHsbCBV4fiyUrp9BvuOC6hff/a1lIaAI5Ad0bAfR1gBsuXcPs+w4z/uIUa+/dsqSfjMCbZ+PWdYwfmWBqfLrTSwkEXoeWCJxPAVshEDIDlSLrwk3tyOumrERkEmVApoJoShIdi7DSIoxAaFzTSA2iWYhnDfGMQc1myHqKSFJItROBPg1s8+OfBJNjU0wcm2TDlnUcPRBqawOvg4BDV7/EsjOH2XDxms7U/3X5/rqFro4AKqkYGRhh+xY/Fi4QeB1UJNl09gZ2PbcHo4P9S6DbybtxbdEJbDMNSQpJiqglyNmUeDqjNGUoTxrKExaZWuIpqByDyqigPAqVUSiPQXncUp40lKYM0UyGqqWIhtsfaYrVGqu18x+0Jx/iMNrw8nN72HTOBqTq6stGoONYTGTYvuVchvuHOxYBFLZ921INPHX9X3IpKnHdOdeFGoLACRlcNsjASD97du7t9FICgZPAOiFmcjsYXaSBaSSIeoKcbaCmE+LJhPJERnlMIxNLadJSOWaoHLVUjxn371FNZVxTmsiIJ1PUdIKcdfshSbFZswbQmpOP/uXs3rGPoeWDDI70z9P5CCwVhBC85dy3EEdxZxbQzvTvEhV/0MUp4JxIRly+5XJ6K72dXkqgy9m4bT2TY1OMH53s9FICgZPEFrWAAoNF5yOAARDGjYdz/oCGyAhkZolnNOVx7ca72abPn0wNInGNJKKRNSN/vgHEGu3TzrYlAnhyjB0ZZ3p8ho3b1jN2ZGJezkZgadBX6eOysy5bcP+/eWOJisCufnbyOsBNKzZx1uqzOEa900sKdCkqUpy5fRO7ntmNzkK5QGAx4SKB1kiEMNiM4oIjrPueE4EaZUFkrrYvnkxcjaAXdMJYhPcSdJFEt7nIX4bVGbQ2gJziVU1nmpee3c0Z2zfxxP3PhDKLwGuyZc0WNizb0JH6P2hJ3QZel65PAQshqJarvOXct3R6KYEuZniFS//uenZPp5cSCJwiLVNBdF4L6KJ3tpFAvQG1OszWEDM1RKZdaniyhpqcdbdTNeRUDTFdg9k61BpQb2CTlvSv9qlf88bzWi8/u5uh5YMMLx9s7ykILB2E4Ppzr6darobxgV1O1wtAgFjGXHfetZRKpU4vJdClnLF9E2OHxxk/GlJTgcWIF2U2F2nGReyyDJum2MTVBdJIwBjX1VtrzN3qjeIxNklc2jfNXNNHUfdneDOFTfnf2Obtm9r5yweWEOVymevOv5ZIdTDB2O4awCUaTex6ASiEQCnFmdvOYN0Zazq9nEAXEpcizty+ieefeCmkpQKLmJZIoDFYbV3Xrm8MsYnfjMGmKTRy0dfAFluCTZMi9Wtbff/eYOq3Fa0NLzy5izO3byKKu7qCKNAh1p+5hs1nbepY+jdw8nS9AASQQtI70MM5H9zMkUt3Ux+e6fSSAl3EyvUrqPRW2L0jdP8GFjteoBkDRnsB6ESgTVMn7rwAtHUv+BqNlqhf4h+X1/3p5vi3NoUyXn52Dz39VVauX/6m9xVYOtRHpjly6W62f+BMevqrSLEo5MVJsVRl7KJ5hiIVcdWtl1E7e5K0P8x4DTTZdvFZ7H/pINMT4YNBYCmQp4N9vZ6fFmLzGkFLMT7O6swJRK3dNBFtiohfUe/3JtO+xzM1Ps3Blw+z9cIz27K/wNIg6W9QP2eKK2+7jFh1yP6lhbb6AC5RFpUAPHfDuWxeubnTSwl0Eb0DPWzYso4dj77gJhsEAksGC5g5XoF5Gtelhw0284JPmyLd23yccT/f5gImay07Hn2ejdvW09Nfbeu+A4ubM1edyTnrzkGpDo1/y2n3pWCJXloWhQAUQiCFZKA6wE3n39Tp5QS6iM3nbCRpJBzYdbDTSwkE5ommELR5Kte6FPHczbRM+Gi/8Gtl30sHydKMTWdvmLdjBBYZAm46/yb6Kn1IITta/ycgNICcBItCAObEKubWC2+lUqp0eimBLkBFirMv2cLOx18iaaSdXk4gsADYltvOXbGSesLzT7zEOZduRUUdjvYEuoKeUg+3Xnhr56Z/tGKdCGzXtlRZNAJQCEGkIs5eezbbNm5Fxxkm0tilLM8Dr8uqDSsYGOnnhSde7PRSAoHTjucff5HBZQOsWBeaQU5XLBYTaXSccfambWxds5VIRqH7d5GwaAQgOBHYW+nl8rsvYM/bnmX/9c9jVbD9OB0RQnDuZdvY98IBJo5NdXo5gcBpx/ixSQ7sOsi5l21d2mGSwGtiI8O+G3ay923PcsXdF9JT7uke8Rd8AE/IohKA4NLAN1x2PX3Le8gqaXjjOU0ZGOlnw5Z1PPPQc6H5IxDoANZYnn5wBxu3rWdguL/Tywl0AAvoSkrfyl5uuPT6ruj+LQji74QsKgGYm0JvXLGRy7de3unlBDrItou3MDE6yYGXD3d6KYHAacuBlw8xPT7DtovO6vRSAh3kqq1XsX7ZepTqEvPnJSza2smiEoAAAkElrvDDV/xwZ0fNBDpGtbfCtovP5OkHn0NnutPLCQROW7I04+kHn2PbJVuo9JQ7vZxAB4hUxDuveCfluIzoppRcSAGfkMUnAIUgVjFXbr2Sjcs3dno5gQ5w1vmbMdqw69k9nV5KIHDa89IzL4O1nBHmA5+WbF55BldsuYI4irsj+gdLVrC1m0UnAAGklIz0jXD7JW/r9FICC0ypHLP9inN45gc7aNTCRJhAoNPUZxs889BOzr/qXOJyF9WABeYdIeCOS+9gqHeo+0a/tTH6t1SngXTZM3byxFHMnVfcSX9fKD4+ndh0zkZKlRI7HgvWL4FAt7Dj0eep9JTZuG19p5cSWEAG+ga447LbKUWlTi9lDoIwCu5kWJQCMPcE3LRpIxdfez7W/xdY2kSliAuuOZfnHtnJ7NRsp5cTCAQ8M5Oz7HjsBS68ZjtRHGqzlzr5NffS6y9k44aN3dP8kRPkwEmxKAUguGaQcrnM9T97JUdu2cX0xrFOLykwz2zatp6+gV6efWhnp5cSCASO45kHdzAw3M+Gres6vZTAPDO1aZQjt7zMDR+9inK5y5o/ckITyAlZvAJQCOIo5pKLLmLjJetIe5JOLykwj0RxxIXXnseOR19gany608sJBALHMTk2xc7HX+Ci684jisN4uKVM1puw+bL1XHjB+cRRF07+aLNg67Lfrm0sWgEIIIVkoGeA9179XmS3vQADbWXT2evpH+rjqQef7fRSAoHAa/DkA88yMDLAhq2hFnApI4TgR675Efqr/d3X/OFpaw1giAB2J6WoxG0X3cbakbWdXkpgnohLMRe/5QKefXgnU2Mh+hcIdCuTo1PsePR5Lrn+AuJSqAVcqmxYvoFbLril65o/CpaoYGs3i1oACiFQUrFqaBV3Xntnp5cTmCfOPG8T1b4qTz/4XKeXEggETsCTDzxD70APZ5wbfAGXKu+49k5WDq5EyS5r/gicEotaAOaUozJve/fN9G6okPQ2sEu5b/s0o1wtc/H1F/DU959lemKm08sJBAInYHp8hqcffI6Lr7+AcrVLI0SBU8YKS9Jbp39TD7e96+bujf7ha/ZCA8gJWfQCMJ8PvPas1Zz3S5vZd/MOdDnt9LICbeKcS7cipeDZh3Z0eimBQOAkefoHO1CxYtvFWzq9lECbyCop+27ZyQX/4kzWnLGSSHVh80cr7TSCXui1LxCLXgCCt4SJy9x141309/ct3WfrNKNvsJcLrtnOI999gtpMvdPLCQQCJ0ltusZj9z7JhdeeR+9AT6eXE2gHwjLQ38f7rn8f5bjL5z570daubalGAZdEla4QgiiKOHvd2dx84U18758eRiUR5bEqUb17w9SB10HAhdedx8zkDC888VKnV3MSCISU9A32Mjvd1+nFLAp6+6tIJent76F/OJyzk6FUjpFqcXxu3/n4i5x72VYuvPY87vuHB5fsRXSp0xicJetJ0eWMWy++jW1rt3V/9A/AhhfciVgSAhBcFLASV/jALR/ga099jZn6DKse2Ez/npFOLy3wBlixZhnbLjqLf/z8PaRJ1unlnJAoVvT0VfjFz/wMOtOdXs6ioG+oj+VrlvFTv/EhZkJ958khBL39VZJ69/uepo2UH3zrUW5+7/XsfOwFjh4Y7fSSAm+A8a2Hmdo8Sn+1nw/c/KOU4y41fm5BtFv8WbskP8AsHQEoBLGKOX/j+dx8wc18+Qdf7vSSAm8QpSSX33IJ+148wL4XDnR6OSfF0f3H+P1f+EN0prHhk+dJcfalW/nwL9/FF//4y+wMs51PGq0N+17Y3+llnBR7nt/PgV0HufzmS/ja//oWRptOLylwqvg86M0X3Mz29duJo7j7o38s7Rm+7WLJCEBwIrBaqnL3jXfzrSe+1enlBN4gm7dvYuW65fzNf/t7jFkcF4xGPeHZh8OIulOhb6iPtJGy94UDPL8o0vyBU8Vow4PffJR3/uTtbD57Ay8+/XKnlxR4A/RV+rj7pruplCpdH/0D2t+9u0TF5OIoJjkFYhVz/iYXBQwsPqq9Fa64+WKefOAZxg6Pd3o5gUDgTTJ6aIynv/8cV9x6CZWeSqeXE3gD3HbRbZy34TxiFXd6KR1hEUjeN8SSEoBCiCIK+JGbP0JfXx9GaYwy2KUq4ZcQQsBFbzkfrQ1PPhBGvgUCS4Un7n8aa+HCa7cv3avpEsJi/bVTM9A70Iz++WvsYqCto+CWKEtKAIKvBYxiztt4Hpf/+PnseduzHHjL81i1hJ/FJcLK9Ss459KtPPD1h2jUGp1eTiAQaBP12Qbf/8bDbL/ibFauW97p5QROgFWG/de/wJ63PcsNP3Ttoqr9A9qfsl2i8mHJCUBwHcHVuMqH7vgx+lb1kPYkLNlncIkQl2Ouvv0KXn52D3ue39fp5QQCgTaze8dedu/Yy9VvuzzMCe52BGQ9CQNr+vjwWz+0eGr/PGESyMmxNAWg9wXctnYb77n6PYvqhXu6sv2Ks+kb6OHBbz2CNUv4Ly4QOE0xxvDgNx9hYLifcy8/u9PLCZwAIeC9V7+Xs1afRawWUfQP2m8EvURZkgIQmr6AH7rhQ6wZWdPp5QReh+VrRrj4Lefz/X98mOnx4AcXCCxVpsamefCbj3DJ9RewbNVwp5cTeB3Wjazng9d/kEocGneWKktXAApBpCI2LN/Ah274EFIu2V91UROXIq6540r2vXiAF57c1enlBAKBeeb5x1/kwMuHuObtVxCFVHBXIoXk7ps+zPpl6xfH1I/jaHcKeKk2gix5VVSOy7z7xnex9vKVzK6aJO0NzQXdxPlXn8vASB8PfP2hYBIbCJwGaG24/2s/YGj5IOddEVLB3UTa22B21STrr1zNO9/yzu6f+ft6LFANoLUWYwzGmFcMAXit77Xe30mWtAAUQqCkYmTZMO/6jbdx5KaXmV4/1ullBTyrNqzgomvP5/5/eIipselOLycQCCwQk6NTPPC1h7j4+gtYuT50BXcLUxtHOXLzbt79G7czMjKMkmrRRf+A9tcAvoYItNZyzz338Cu/8iv85m/+JocOHSqEnrWWsbExPvWpT/HLv/zL/P3f/33xvXq9zr/8l/+Sv/zLv5yP3/6kWdICMKccl7n1wlu55pxrlnZF5yKi0lPmLe+4ipeeeZmXwnSAQOC044Und7H7ub1cd+dVlKulTi8n4HnL9uu4+YKbKcWL/DlpewTQYm1zA5icnOQ//+f/zCc+8Qkuu+wy/uiP/mjOEj73uc+xadMmfvVXf5U/+7M/4/Dhw1hr+Zu/+RuOHj3K3r175/MMnJAlLwCFEEgh6e/p52Nv/xjRBsHYtkOMn3UYo3Snl3daIqTgspsvRkUR3//HRzoeBg8EAguPMYYHvvEQpXLMZTddvDgjTUsAE2nGtxxmbNshShsVP3f7z9Ff7UcKuXifkzbX7Flr+fznP8+nP/1p/sf/+B+FADxw4AD9/f2sX7+eK6+8kp07d5JlWfFzjz/+ONdddx2rV69m9erVvPzyy7z44os8+eST3HHHHR0/v0teAIITgaWoxEWbL+KO99zGsYv2MXr+AUwcBGAnOHP7JrZeeCb3fuV+atO1Ti8nEAh0iNmpGvd+5QG2XXwWm8/d2OnlnJboWDN63n6OXbSPO9/zNi7YdMHiMn1+Laxt2yaAK6+6ine+851ce+21xbmx1hbTUYQQr6gBNMYUDahSSpIk4T/9p//ETTfdxOTkJGNjY9RqnbsGnhYCELw5dKnKT9zyE2xasanTyzltGV4xyDV3XMmj9z7J/l0HO72cQCDQYfa9dIDH/+kprnv7lQwtH+z0ck5bzlh1Bh+5+SNUS9XF7Z1r8cKN9m3Axg0b2b59O2eccUYhAFeuXMnk5CSjo6M888wzbNiwASklL7/8Mlprzj77bB577DGmpqY4ePAga9asYWhoiG9+85t8/etf5/777+9oGvj0EYDeFmb9svX87O0/e9oOte4kpUqJ63/4Wo7sO8KT9z+9pB3WA4HASWLh8X96mqMHR7n+nVdTKof35oUmjkr83O0/x9qRtYvS9uV42r3619rfyMgI73//+/nkJz/Jl770JT760Y+SJAmf/exnmZ2d5SMf+Qjf/e53+Tf/5t/w9re/nTPOOIN/+2//Lf/u3/07PvrRj/KhD32IrVu3tnm1J89pZ8JUjsu8/bK3843v/yMvfPVQp5dz2iCl4PJbLqant8I3P38PWRrS74FAwJGlGd/7ygP80EfexmU3X8z9X/tBmAi0QAjgxvNu5PZLbl/cti/H0VbvvtfYlxCC97znPdx5550opYgiJ6l+7/d+j1KpRH9/P5/5zGfIsoxyuTxHWN9yyy0dr38/bSKA0GwIGagO8PM/9HGGhgaxwmCXqstjF7H1orPYduFZ3PM39zE9EaZ9BAKBuUyNT3PP397H2ZdsYesFZ3Z6OUseKyxWGIaHh/n4Oz6++Bs/WlnAS7oQgkqlQhzHRS1gLvbysbSVSuUV51UpRRx3Ntp9WgnAnDiKOffMc3nbb7yF/bc9z9jZIRI4n6zeuJKr33Y5D37zkVD3FwgEXpN9Lx7goW89ytV3XMHK9Ss6vZwlzdg5B9l/2/Pc/hvXc/bmbZSiRW77cjztrAFcojGi004ACiHcnOBShR95x3s599JtZD1Jp5e1ZOkf6uPGd1/Hi0+/zDMP7ej0cgKBQJfz1IPP8fKzu7npPdfRN9jb6eUsWdLehPMvP5f33fkeKiU373dJRP+gGN/Wrm2pctoJQGhOCFnWv4xPvPMT9PX1okspupSGdHAbKVVK3PCua5mZnA2j3gKBwElh/Ki4+kydG374mtAU0kassMW1rr+vj1965y8x0jeyeCd+BN4Up6UAzClFJa7YcgXv+tCd7LnjOXa/9VmS/nqnl7UkUEpy9dsuo2+wl+986Xsk9RBlDQQCJ0ejlvDtv/4egyMDXPnWy5DqtL5UtY1koMbutz7L3jue4z0feieXnnXp4p/48SqIdqd/l2hc6LT9q8oLNKvlKh9560c47+xz0eVsacd7FwghBBdedx6bz9nIt//q3jDnNxAInDKTo1N864v3cuZ5m7ngmu0hQtUGrABdybjg3PP58dvuLjz/lua5bZ/6W4pnB05jAQjeG1BGrBhYwa+861cY7Bno9JKWBFsuPJOLrjuf7375fg7tPdLp5QQCgUXKwd2H+d6X7+eS6y/grPM3d3o5S4LBnkF+5V2/wvL+5Us39dvuGsAlGhc6rQVgTikuccXWK/iJW34CKVWnl7Oo2bBlHde9/Up+8M1HeemZlzu9nEAgsMh58eldPPTtx7juHVex/qw1nV7OokZJyU/d+lNF6ndJij8AbEj/ngSnvQDMu4KrpSp333w3l154caeXtGhZuW45N73nOp7+wXM8/eCzS/oPJxAILAzWwlMPPMtzDz/PTe95CyvWLuv0khYtV1xyOR++6UOLf9zbCWh3JddSrQw77QUgNLuCh/uH+T9+60PYW2cZ33oIGxTMSTO8cohb77qBl5/by0PffgwTXPwDgUCbMMbw4DcfYc/z+7n1rhvDzOBTwGIZ23YIbqvxU5/8MYb7h5du6reFYANzYoIA9AghKMdltp53Fh/55z9Gui50A58sA8P93HbXjV5vutAAACrsSURBVBw9MMp9//AgOgtj3gKBQHvRmea+v/s+o4fHuO39N9I/1NfpJS0asvV1fvLjH2bLOWdSipZy6reFkAI+IUEAHke1VOXdV72bOy+/E6Qfl7OUXwFvkt6BXm57/43MTM5yz9/cR9pIO72kQCCwREkaKfd86Z+ozdS57a4b6R3o6fSSuhaLdb62En74ynfyw1f8cGH4vNRpe9RuiUqAIABbyGcF91f7+dhP/Az9H5bsvXkH9WVhdu2r0dPfw2133UCaZHzrr75Lo9bo9JICgcASpz7b4Ftf+C7GGG79kRvo6at2ekldSX35DHtvfo6BuxUfvfun6av2LZ1ZvyeBsLZt21IlCMDjEEIQq5g1q9fwL37mF6lsiDBxSGkeT09fldvuugEhBN/8/D3UZkLKPBAILAyz0zW+8ZffQUWKW37kBqp9p0dk61QwcUZ1Y4lf/plPsHrVKmIVnzbir/0Ru6UpAoMAfA3KcZkrt17Jz93xc8iyRJcydJyFdDBO/N16140opfj6X36HmanZTi8pEAicZsxMzvL1//1tSuWYW4MIBFzaV8cZupQhK5KPv/3jXLHlCspxudNLW9QsVdkcBOCr0GoN88HrP8gVP30+e25/hoPXvAjy9BaAvf093Pb+G1GR5Ov/+9vMTIT0eCAQ6AzT4zN87X99m1K5xG133UhP/+mdDrbScuDaF9lz+zNc9dMXcdd1d1EpVZbwtI/XJnQBn5ggAF+D3BpmoGeAf/H+X+KcbWejy6d3KrhvqJe3fuAmhBB8/X99m+kg/gKBQIeZHp/ma//zW6hI8db330TfYG+nl9RRTDlj+9nn8kt3fYKBnoHTwvLlFYQmkJMiCMDXIa8HXDuyln/7/n/LsuERGoM1GoOz6FLW6eUtKIPLBrj9A7eQpdpF/iZD2jcQCHQH0xMzfP1/fRtjLG/7wM0MjPR3ekkLii5lNAZnSQZrLB9Zzm++/zdZO7z29Kr7a0FAsIE5CYIAPAnKcZlLzriEX7r7Fzl2+2723Poc0+vGO72sBWPZ6hHu+LFbmZma5Rt/+R1mp2qdXlIgEAjMYWZylm/8729Tm6lzx4/dysiq4U4vacGY3jDGnluf49jte/gXH/4EF26+MNT9tZGlmgYOAvAE5PWAlVKFd1z+Du6+5W5kJJbuK+I41mxaxR0/dgtHDhzlm1/4LvXQ7RsIBLqU2kydb37hHo4dGuOOH7uFVRtWdnpJC4IVFhkLfuKtH+HOy+4s/P5Ox+gfANYiTPu2pUoQgCdB7g/YW+nlo7d/lNsuuo3GSI2pDaNMrx3HStPpJbYfAZvP3chbf/Qmdj27m3u+dB9JPen0qgKBQOB1adQSvvOl77F75z5u/+DNbDp7Q6eXNC9YaZheO87UhlGS4Rq3X3w7P/3Wn6a30nta+f29Ku1M/y7hNHAQgCeJEIJIRoz0jfBvfuTfsOnGNRy6ehdHLt2DUUtLAAop2H752dz07ut48oFnuO8ffkCWnl41j4FAYPGSJRn3/d33eer7z3Lze9/CuZdvQ8ilJYhMZDhy2W4OXb2LM25az6+/79cZ7js95vwuOEEABoQQxFHM+mXr+T8/+H+ydnhtp5fUdqI44opbLuHK2y7lvr9/kEfueQKjl5bADQQCSx+tDQ/f8zgPfO0hrnrrZVx+88WoSHV6WW1n/bL1/PYHf5t1I+tO26aPVxCifydF1OkFLEbKcZnzN53PJ3/0k/zan/4ao9sPIrWgcqSf3kMDnV7eG6baW+G6d1zF6g0r+cZffoe9z+/v9JICgUDgDWON5ZmHdjA9OcON77qWgeF+vvfVB6jPLt6xlTOrJ6gvn8YoQ/9AP5/80U+yfcP20PRxPEt4hFu7CBHAUyT/dFWNq9x4/o184n2foL59grFzD1FbOdXh1b1xhlcMcceHbmVw2QBf/e/fCOIvEAgsGfbs3Mff/fd/ZHjlEHf82K0MLR/s9JLeMLWVU4yde4j6eZP88o/8C67ffj2V+DRv+jietvsALk0xGQTgG0AI56reU+7hrmvu4idv/UmUVFhp3BiexTQyTsDGbeu588ffyszkLH/3599g9NBYp1cVCAQCbeXYwVG++uffoDZb5x0//lY2bFnX6SWdNMWItzjDKoOSip9+60/z3qvfS0+5p7gmBXIWyfW3w4QU8BtECIFE0lft42dv/1mOTh7li8lfM71+HKkla+/ZQjzb3SF5FSnOv+pcLrnhAp76/rM8cs8TodkjEAgsWWanZvnHz9/DpTdeyK133cDD33mcp77/LDrr7ilPWW/C/uufdw2HZcv7rnkf/+yt/4y+Sl/o+H0Vwtk4OYIAfBPk4+IGewf51ff8Ksemj/GtJ76FyWTXvwJ7+qtce8eVrDljNd/92/t48amXsUs0zB0IBAI5WZLx4D8+wuihca694wqWrxnhvn/4AbXp7jW4t8KSVRNsZLntotv4l+/+lwz1DIWO39fhNLHqfVMEAfgmycfFLR9Yzm/96G8xOTvJwzseIemvY5RBpQpVixFdpAhXb1zJ9e+8hizN+OqffZ1jB0c7vaRAIBBYMKyxPP/4i4wfmeCGH76Gd/z4W/nu397HoT1HOr20Aoslq6aYWJP1JiDgii1X8Mn3f5Ll/cuJVBTE32thaW/d3hIVk6EGsA0IIShFJdYvW8/vfPh3OHvjNg5e+yJ7b3uWY+d3TzOFihQXXLOdO37sVg7uPszf/fdvBPEXCAROW44eOMZX//zrHN53lDs+dCvnX31uV1nFHLtwH3tve5aD17zIuZvP5Xc+/DusXbaWOAp2LwuJWKIKMAjANiGEoByXOWv1Wfzu3b/LxtUbscpiZXe8cPqH+7jtrhu4+C3n809/932+95X7F7UVQiAQCLSD+myDe//2fu7/hx9w6Q0Xcsv7rqd/qK/TywLASotVls1rN/O7d/8uZ6w6g3JUDuLvBAjb3m2J6r8gANtNJa5w3sbz+N27f5c1w2vIehJm1o0zvW4cXVr4BgshBWdu38Q7f/IOSpUSX/7c19jx2AuYJTzfMBAIBE4FYwzPPfI8X/7c16j2VnjnT97O5nM3dmR6iC5lTK8bZ2bdOFk1Ze3IWv79h/89564/t7B7CZyAYAR9UgQB2EbyT2WVUoXLt1zO73z4d+g7s4eD17zEwatfJOmvL+h6evqrXP9DV3PDu67l2Yd28vd/8f9v796joyrv/Y+/996z5z6TTCb3hJAECEkIhECEBIhcJQiC8BOsl2q91FqPPdLWHk9b26OopXpcSz3naE91Vatt1Wp7tLa2altviBcsoqDcEcIlkIQAuV8mM3v//ggzBooYdcgkk+9rrawFw8yeJyGz5zPPdz/f5xWONTQN6BiEEGKoOFp/jBcef5kdH3zMrKXTmbGoAofbMaBjCHg7qavcTV3lHhLyXdx52Z1MHjUZu1V6/X0uEgI/kwTAKFMUBQUFu9XO9MLp3H7xbfjcvoEdg6qQU5DN4isXkJKZzItPvMKG1zfSE+gZ0HEIIcRQ09Pdw/rXPuClJ18hLTuZxVdWk1OQPeCzgUmeJO645A4qCiqwW+0oSK+/fotyCThef+oSAM+AcAh0WB3MmTCH2y6+jUR3Ii15RzhSfJCW3MYz1ija5XVy9uJK5lxQRc3WvTz/2EvU7a0/I88lhBBxyYRDNfX86dG/snf7fuZcUMWMRRW4PM4z9HQmzXmNve8PeUfwuX3cfsntzCyZicPqkPAXa3E6AyhtYM6Q8IvVaXUyf+J8gkaQW568hWOdR7A3uvDs9Uf1l0rTVPLG5TJlbhmd7V289MQr1O2rj9cdbIQQ4ozr7uzm3b9tYP+OWiqqy1ly9QLe/fsG9mzdhxEyovdECrTkNdLt7yDBmcCqi29n3oR5OK2yy8cXYppxu31bNEkAPIMiIdDm5NxJ52IYBqueWkWA3q7z4VnAL9sjMCnNx5S5ZaSNSGXT25vZ/O42Al1S7hVCiC/LNE0O1tTx/GN/pWRqITPOq2D0+HzefXnDl76m+uRKUIIzgVsvupXqidWyxZs44yQAnmF9Q+Ci8kUoisLtv7qDusrdKCGV5A+ysXTrX+jYdqeNkqlFjJtaSP2+Bv706Euyj68QQpwBga4AG17fxN7t+5kydxJLrlzAR+u2svndbV+4pVZXchtNYxpAAVe6g/+4+McsKFsg4e9Lkp9a/0gAHADhfYOdNicLJy9EURRW/XYVzc3N+D/KhM957tAsGnlFOUyePRFMk7XPv0PN1n2EolmSEEII8U+O1B3jr0+9Rm5RDuWzJzJqfB7vvfoBNdv2f+49hYPOAO3ZzfhcPm69+BaZ+YsiJao7gcRnOVkC4AAJh0CXzcXCSQvRNZ1bf70KUzUwVON4s0nltOVgRVVIz0mlfNZEfGmJbF637Ut9+hRCCPH5hYIhPv5wD7W7D1EypZAZiyoomlzA+tc+oH7/YczT9Fk1+WSDAFM18Xv83H7x7cydMFfCX7TEaWCLNgmAA6hvOficieega1ZWBW6j7tgenIcS8H+Y+SkPhKRUH2VV4xkxJouabft54/m3aWpsGcDRCyGE6KurvYv1r37Aro/2MKlqAgsumcu+HQd4/40POXa46ZQL/UzN4NC03YQcPSSnJLP68ruoKq6SBR/RFs01OnGaJyUADrC+q4Nnj5+F7XorP3z8h7Q0d57y/gl+L+Mrihg9Pp/6A4d54fGXadh/GFM+4QghxKDQdLiZV59dS9qIFCbPKmXJVQvYtWk3H76zlZajrSfeWYEeTzdpOSn89KurqSio6G31IuEvanr798l75GeRABgD4Re5w+ZgetF07rnyHlbdcwdN+5vBBMcRDwmuBMZNKWTsxNE0HWnmlWfe4MDHB6PbekAIIURUmKZJ3b4GXnz8ZbJHZ1J29gSWXrOQ7e/vYsu722nqaKLL34ZhMcnLyuMnV91OWV6ZNHk+E6Kd/eI0S0oAjBFFUcDs3TZu8qjJ3Pn9n/D9X3+f+mP1VHVOp2RkCa1Nbbzxp7fZu+PA5764WAghxMALhQz2bj9A7e5D5BSMYOKMEsZOHM2Hez/k7/Y/k+nP5M7L7qQouwib1Sbh70yJamiLzwQoATCGwiHQYXVQklPCg9c9yDvb3+HQ34+y9s/r2LfjAMGeYKyHKYQQ4nMK9oTYvbmGfTsPMLIgm3HzCvjB3B9QWVhJpi8Tm24DZG/fM0JmAPtFtoKLsfCL36bbyEnJYXbJbA6072ODuY6jmfVnbMs4IYQQZ5aJydGMet4z1nGws5Y54+cwInmEhL8zzvxkN5BofMUpmQEcBMInAYtqwe/18283fxvlD0H+8vxLePYmxXh0QgghvhAFOsY0sei8Bdy49Ab8Hj8W1SLBbwDIIpDPJgFwEFEUBavFSmpCKj9c/kOyQjm8+OYbBLoC/3xf6XUuhBCDxqmqNTa7lWsXXcvlyy8lwZmARZPwNyCiHf7iNExKABxkFEXBolnwuX18/eKryHBmcN/v/5uWjmYAtC6d5E1ZYMhJRAghBgtTNTlSWkvI1rsPe4Izgeu+8h0Wnjcfl9OFpmoS/gZSfGa2qJIAOAgpioKmanhcbpZcsAjvWBernlrFoWOH0FttmB9myvyfEEIMJqpJe3ozQXeArKQsbvnKzZw97mycNieqokr4G0iyCKRfJAAOUn23jps7YS4p3hR+/OSP2bn1Y0zVxDANFFNBMeWkIoQQsWIqZu+XaqIoCiU5Jdx+ye2U5JRg1+3S4DkGFIhq2TZe//ckAA5ikYbRVgeleaU88I0H+MlTq1lrvIlhmCTuSMW71x/jUQohxPDVknuE5tGHUTWV2RUz+eGFP5SVvrFmmlFeBHKavZ1Nk2AwiKqqqOqJM72maWIYBoZhYLH0Xv8Zvr+iKGhabC8LkAA4yIV/Yey6nZEpI7nzip/yQOoDPL7mcUJ7pUegEELEUsgWREkx+OrMS7luwXUkuZPQLTog4S9ufEr+M02TF198kRdeeAGr1crKlSvJzs6OvG83NDRw77330tHRwcyZM1m2bBlPP/0069atIxgMct555zF//vyY/Z5IABwCwr8cVouVZG8yN55/I/lp+Ty6+wmC9h4wQeu2yMpgIYQYACYmIXvvB3CfL4EbL7yepVOW4nK4pM3LYBH16/ZMzD6zioqi0NTUxGOPPcZ9993H+++/z89//nPuuOOOyH0ee+wxJk6cyPz58/nWt75FZWUlZ599NosXL6ahoYHvfe97VFVV4XQ6oz3YfpFG0EOIoihYVAtep5cLp1/Iqv+8GevXAtTO2UHIJrOBQggxEEL2ILVzdmC/Msjtd/2Y5dOW43F6JPwNFmZ0v0zD4PHHH+fWW2/lkUceiQTB+vp6PB4PqamplJaWsmfPHoLBT96Lt2zZQnl5OT6fj4yMDPbv309mZiZOp5P6+nr8fj+6rg/Ij+RUZAZwiAkvDnHanVQUV/DADffzn0/eze7X62M9NCGEGBZUTWV2+Sz+/aKbGJk6Epsue/oOKuHwFiUKCuecM4+ZM2dit9u/0P9zODSapsnWrVt58MEHufnmm7FYYhfDJAAOQeE9hO1WO6PSR3HX1Xfyfx3P8/STz9DR3dF7HxSszQ7UkEzyCiHEF2VoIQIJXZFGzy67i4svXc6yqxaR6EnEarECcr3foBL1LdwUUlPTyM3NPeHWtLQ0WltbaWhoYOPGjeTl5aGqKtu2bWPUqFEUFxezfv16fD4fdXV15OTksG3bNn76059y0003MXLkyCiO8fOTADhE9b0u0J/o59J/W07aOYnc9exd1B6pRTFUsl8ei63FEeORCiHE0NXj7qZ25k5M1SDbn80NF6xkzoQ5uOxOae48XHxKmExMTOSKK65g9erV2Gw2brjhBgKBAI888gg/+tGPuOKKK7j33nt56623WL58OampqTz00EMEAgEeffRRkpKS+O53v4vDEZv3aQmAQ1y4abTb4WZB+QLyM/JZ/X+rWbdlXayHJoQQcUHVFCqLZ/CDC35AQWaB9Pcb9KJcA/4UiqJQXV3NvHnzei/PUnsrbqtXr0bTNDweD3fccUekDQzAzTffjGEYkcdLCVh8KZHrAq1OikcUc9/V9/GLlx7mLx//nebmdvQOK456j6wSFkKIfjAx6UhrIejswebT+Ub1N7jqnKvwe/xS8h0qBqgP4KlCXN+/a5qGpmmn/LdYGzwjEV9K35JwakIq316ykgn547n72btp3HgYR70nxiMUQoiho7ngMKkTkrhp2Y3MKpmF0+aUVb5DRVTDX/ySABhnwq1iPA4P1ROrKcgo4GcPPcSWd2sIBfu2iuldSCKzgkKI4czsPRHSd5ZH0y0sKK/muq9/g9zUXCn5DkUSAj+TBMA41HcLudEZo1n13R/zh5I/8fMXfs7R1iOYgLXVTtq7uXG7ybUQQvSLYlI/tYaAuxsF8HuT+ea532Tp/MV43B7Z1WOoimoFOD7fKCUAxqm+JeHEhEQuOn8FxRPHctczd/He7veO38skfre5FkKIz2YqEPB0EfQFOGv0Wdy07CZKRpbg0B3/tLerGCIMohwAo3isQUQCYJwLrxJ22p1Myp/Ez679GY+++ihPPff73q2MDAW1R0M1pF+gEGL4MDQDwxLCVE28bi8XnXshX5v9NZLcSVh1qzR2HuridNYumiQADgPhxtE23UZqYir/uvBfqRhdwT059/LRvo/wv5+FZ19SrIcphBADpi37GEcnHmRC7gR+suIeyseU47A60NTeFZsS/oYuJcrhT4nTLCkBcJgIn8wsqgW33c204mmM+fYYfvnKL/n7zrUxHp0QQgwst8fFssVXceWcK0nxpmC1WGWhRxyJbgiMzwQoAXCYCZ/c7LqdDF8G31n8HeYlV/PLO59g884tGGZvg0pLl46l0xrLoQohRFQEHQGC9h4AVEVlfGEJV/z7xZRMLcJhc2BRe98KJfzFi2hvBRefJAAOQ5HZQK13NnBy1URGTsjmN68/zq9f+zVN7U34tqXh35wZ45EKIcSX1zzqMMfGNuBzJXL57Mu5dOal+L1+udYvXkU7+8VpmJQAOIyFyx023UZaUhrXL/oXqsbN4L+e/y+276yJ9fCEECIqNIuFqpIZrDxvJSU5JZFr/ST4xSszXqu2USUBUESaR7vsLiaPnsz/XPM//C39VX77i99z8OjByOvIfsSFtc0e07EKIcSnMTHpSm6jxxUAehvdZ/oz+cY1N3LOotkkuBLQLbrM+sW7qM8ARvl4g4QEQAEcnw1EwWax4ff4WbZiMWUzx/PgXx/kL+/9hc5AJ6n/yJEAKIQY1JpHNdKWcwyH1cHisxZzzTnXMDJlJHbdLn39hpM4LdtGkwRAcYJI30CbkzGZY7jt4ttYULaAB/7yAHXvNcd6eEIIcVqqqlKWV8b1C6+ncmwlTpsTXZPdPIYVEwmA/SABUPyT8ElS13S8Di+zx8+mNK+UF7L+xpPPPkVdU11kRtxZ78FVlxC7wQohhq329GY60lqB3j2NMnwZfPerK1k071x8bh82i01auwxLUQ5/cRomJQCKT9W3ZUxaQhoXX7KCirnlPPzyw/x5/Z9p725HDaoSAIUQMdGZ3EZzQQMuu4vF5Yu5au5V5KbmYtNt0tB5OJMZwH6RAChOK3zyDJeFC7IKuPUrt7LkrCX874v/y87t+zBP8WlLkT2GhRBRdKrzjG7RqSqu4pvV36QsvwyH1SHlXtEb/qIZAOM0TEoAFP3StyxscVioHFvJuJxxrClZy2N/+BXbD+7AMHqbSDsbvPi2p8VyuEKIOGJicqywns6U3nKvqqoUZhWyctn3ObtiBh6HR3byEH1IAOwPCYDicwmfXG26Db/Fz8I5C5hafhbPrHuG37z+Gw4ePYilS4/xKIUQ8SaQ0ElneivZ/mwum3UZ5085n2RPMlbdiqqogMz6ieOkBNwvEgDF5xY+yaqoOKwOMpIy+Pq8r7OgbAFPrHmCl559me7EjhMfE1TR22xSGhZCnJaJSY+7G9NinHC7z5/IJfNXcNGMi8j2Z8t1fuI0pBFgf0gAFF/YydcH5qfl872l32Pp1GX8+pVf8cKGF2npbAHAcdhN5prRsRyuEGIoUODw5H10JrejAF6Hl4WTF3LZnMvIT8/HrtuxaLJ3r/gMUS0BR+9Qg4kEQPGlnbC3sOZmXE4xt1xyCxdWXchjrz7Gy5texlDi9BUkhIg6UzVxO13MK53H5bMupyi7CLvVLgs8RP+YshVcf0gAFFFz8kKRsvwyCrML2Vizkd/+8Xd8eHA7Hd0dkRemGtRw1nlRTDmZCzEcmYpJR3ozRrjcq4DT5qS6cj4XL/kK40eO713ZK9u3iViK0zApAVBEXXhbOavFiq7pVBRUMOGGCWxcvJFfvfYr3tjyBh3dHegtNkY0FKGE5KQuxHBkqgaNpbX0eLpx2pzMHDeTy2ddzoTcCZGWLrKyV3xusgikXyQAijMmfNIOB8HKsZWU5payqWYTv3n9N7z9zroYj1AIEVsKboebaZPncenMSynNLT0h+IGUe8VgEJ9hUgKgOKP6nrwjM4JjKyjNK2Vr1TaeT3uJVze+SktHCyagBlUSd6SihrTYDVoIEXWGJURTQQOGZvQu7nB6mVM2l/Mu+w8K88dK8BPRE/VG0NE71GAiAVAMiFMFwUlFZRSvKmLpwYX87q3f8eL7L9LU2Ix3d7IEQCHijGExaB5zGF9yIgvKFrBi2grGZI7BrtvlGj8RfVEtAcdnApQAKAZU30/3VsWKbtEpzSulMLuQy2ddzp/WPs97m7fRuPsohml8+nGkn6AQg8qptmoLU1WVzOx0Fi+cxeLpi8lJycGm27BoFgl+IvpkK7h+kQAoYia8WETXdHRNZ2zWWPL+Xx5Hph/l1dfX8Mxbz7Dj4A6CoWDkMfYjLnxb02M4aiHEpzlafIjupE+awFs0C2OzxnLBtAuYeXYV/nQfVotV+viJMyvaATBOSQAUMde3j6BFs2AbYWPFRcs4Z/Fs3t7+Nr9763es37WezkAniiFvGEIMVt2+DjoyWnDanJSPLmdF5QoqCytJcCZgtVhl5w4xNMVpmJQAKAaNvjuLOKwObLqNRZMXMbtkNpv3b+bZdc+y7qUNYDFPLA+bCoqhSFlYiAFiYmKqJvRp8K4oCqm+VCpnLGJZxTKKRhThtDrRLbrs1SsGmEm8XrcXTRIAxaDTd69hm27DarEyZcwUJuZN5NCcQ7yy9DX++I8/svPQTnqCPVibHaS/kyevdyEGimJSX7GHgLcL3aIzNnMsS6YsYdbUmWSkpkcWekkPPxEzcTprF00SAMWgdfKCEavFSl52Hpcvy2Zp9RLe+/g9nnv3Od57+wMUBQmAQgwUVcGT5qa8oorzp5zPpPxJeJ1edIuORZXr+0SMGVHeCi5Ow6QEQDEkRK4TVC1YrBZsuo25pXOZUTyDA+fU8u64D3jj+bfZvXcPgZ7ACY/VunRUQ43FsIUYsgzVIGTvOeE2q24lPzePsxdPY8oFE8nKyMSm29A1KfOKwcWM09AWTRIAxZByQnnY0lseLsgbQ963c1l0zTw27t7E8+uf582ta2loOYwZMsh4czSORneMRy7E0NLlb6du+scoqkpqQipVRVUsKl/EhLzxuN1udE1H07TItbcS/MRgYUJUZ+3iNUtKABRDUqQ8jIKiKb2rh602zp5YRUXJVOqb6nlz25u8sP4FGja2EWqM8YCFGGI8HjejS2dw7qRzmVY4jbTEtEgLF5ntE4OalID7RQKgGPIiq4cVDVVRsVqsOFIdZPmzWHLWEmrn1fGPlzaw9pV32HFgJ12BLsJnByWkYj/qQjHljUwML6Zi0uVvx1TDK+oVHFY7BdkFTJ9bwZTqMjJHp2O32ntn+6SFixhK4jS0RZMEQBFX+raS0VQNm8WGe7yb/OKRnHfdfLbXbuflTS/z+uY17KnfjdEMOX8rQgnK1nNieDEsIeqn1KAlKOSl5jGzZCZzJ8ylILMAl90lJV4xdEU7/MVpmJQAKOJS3xXEinK8RKzbmDJmCmX5ZVxbfS1bDmzh9XfXsHtvHYd2NdAT6DntdlYgW9CJwa8/v8O6TSdndBbnVFdydnkVRdlFeByeyCrevq8fIYakOA1t0SQBUMS9k0vEukXHbrUz3T2dqWOm0n5eBx9vrWHthrWs3bqWPfV76OrpOuFtVDEUkjdlobfbYvNNCNFPPe5ujoyvxeyz8F0B7FY7+WmjmFE0gxmTppFfmIsrwRmZ6ZPr+kT8MOE0e8l/oePFYZ8xCYBiWDnV9YL2FDsJSV4mVBRzedcl7KrbxVtb3+KNrW+w4+AO2jrbMA3wbU1Hj/H4hfgshjVEe2YziqrgdrgZmzWWqqIqphVOY1T6KNx2d2TbRQl9Ii5JCbhfJACKYeuUYdBqx+f2UZZXxlXzruJA4wHWf7yetZvX0vhRB23tnQSN0OmPayiyqEREnakc337tNCyqRmpaCuPKcplePJ3y0eVk+7NxWB29oU/Ku2I4MIluaIvP/CcBUAg4RZlY07HrdrwOLwVZBSyftpympc1s+3gH72x/m3/s+gc1DTW0d3dgnlRqSNqagWdfUiy+DRHHWnOOcqyw7oTbFEXFZXORl5ZL+ahyKsdWUjh6LInJCZHr+TRVk9Anhhcz2m1gonisQUQCoBAnOdUCErtux5XtIj0zjRnTKuno7mB/434+qPmAdTvW8eHeD6k7Vkd3sJuQHozxdyDikWEN0uPtxqbbSE9MZ/zI8UwtmEpZXhnZ/mycNicWzRJZAQ+AIguXxDAV1bJtfCZACYBCnEbfGZPwG6vVYsVhdZDoSqRoRBErpq2gpaOF3fW7+WDPB+x07OVQ8AiNxxoJBAOfeurQAhqqtJ8Z1kxMDGsQw3Lq3xIFsFqspPhSKJ0+ljHVIynLLyMvNQ+v0xsp6/ad5QOZ6RPDnRm31+1FkwRAIfrp5DfY8OwgOjhtTlISUigfVU7PrB5aWlrZU7+HTTWbeH/3+2yr3UZ9cz3dgW5MekvG/o3ZJOxJjtW3IwaJw2UH6MhoBkBBxW61kZaYTmHWWCbmlVGaW0peWi4eb2+bFk3r/SASXsABEviEOIGB7ATSDxIAhfiCTpgd7HvtoNWOy+EiNSWF8qLJBEOX0dLVwoHGA2w9sJWNNRvZsn8LXXtB1VSMUDTbFYihRNM0EhK95I3OpnhEMRNGTqB4RDHZ/mw8Ds8JJV0JfEL0V5RnAOMz/0kAFCJaPi0QAjjtTlK9qZTmlrJ82nK6Al00XdLCwe117PpwDzs37aZm314amutp7+rAME+/0ljt0bA2OeT6rkHAxKQ7sRNT/4z/M1XDZXOSlpBGbm4uY8bnM6okl4xxKfj8PuxWe6Scq6qqBD4hvpDenn2f1RD98x8z/kgAFOIMOVUgtGgWbNhwWp0kuhIZkZvFWeeUEQwFae/uoLH5MDUNNWyr3cb22u3sadhD3bE62rra6An1RI5nP+Ii67WCeD0vDS0KHJ60j+6kjsgNumbB7XCTnphOXmoehdmFFGYVMjJ1JCnelMiCDVVVI7N7cg2fEFEibWD6RQKgEAPk5Dd4FfWT1ZqAy+7C701iTNYY5pTOIWSE6Ax00tTWxIEjB9jTsIddh3bxcf3HHNnVhC3BRXd7N8Ge0888iTPHomvYXDbyMvJIHuUjPy2f0RmjyU/LJ8ufhc/VO7MXLuNK2BPizDOjXAKO7mzi4CEBUIgYOlUo7Nvs12VzkeROIjctl2mF0wgZIYKhIJ2dnbSt7OBw7REO7a3nwO6D1B6qpfZoLY0tjbR0tBAIBggaQcx+nQgVXIe86B3xv9Vdj7Ob9owW+vOxXlEUNNWCTbeS4EzA7/GTlZRFdmY22fmZZOSkkpzlx53qxOFw/FMJV8KeEDFgRnvrNgmAQogBcMpQaJrQp2OM2+Em2WeSMyYbwzAwTINgKEhPqIe2zjaOtR+jobmBQ8cOceDIAQ4eOUh9cz2HWw7T0tHSW1IO9hAyQhimASbo7aOGRQAMJHTSWLYfFFAVNdLax21343V6SfYmk5aY1hv0/Nmk+9JJS0gj0Z2I2+5G1/TINmrhoKcoygnX7IGEPSFiaaDaAJqmSXd3N5qmYbFYTnjdm6ZJKBQiGAxis9lQFAXTNAkGg4RCochtsSIBUIgh4OSThKZ8kgb7zvCZmCS6Esn0Z1JsFkfCYSQgBnto62qjtbOVY+3HONJyhMMthzncfJhgskrnnh5ajrbS2tRGV0c33Z3dBLoCBHtCmIaBYZqYxuD9NKyoCqqioKgqFl3Dardic9iwO214fR68Pje2PB39LIPUhFSSPcn4PX6SPEm47e7egGfpE/COh7xwwFMU5YSFNxLyhBiETCCa56lPOZRpmjz77LO88sorqKrKypUryc/PjwS9gwcPcvfddxMKhZgyZQqXXnop+/fv55577iEUCjFjxgwuvPBCVFU99ROcYRIAhRjiTpgx7N36Ae34dOHJ5V/TNEnyJGGaJoZpYJpm5M+h+SGMoIlhmhiGQaArEAmBHW2dtLd00NHaQXtrBx2tnb1fbR10tnXR2d5FoDtAoCtAoKuHnkAPwZ7g8a8QoWAoEh7Dz5no96JZNBKTE0jJ9MPx3oqKoqCqCppFw6JraBYLutWC1aaj23SsNitWhxWHy47T5cDhtuP0OHF5nTjdDpweJ26vE4fbgd1hw+awYXVYj8/WKai6gmb/5Fq8k8PdyaFOQp4QQ0vvOSZ67bVMjp8njd5jhs8bR48e5emnn+aBBx5g48aNPPTQQ9x5552Rxz366KPMnDmTuXPnct111zF79mwefvhhqqurmTZtWuS2tLS0qI3185AAKEQcO12YOTkcrvvbBtqb2nEnufH4XLgTXST4PDhzUns/0X7Gc5nG8VDZJ+T1/vmTE7JpmBjH/1236ngSXdx437/QEwgen7k7HgLVcDg7frKN3K5E7sdpWuAogGGadLZ00tbUzrFDTbQebaP1WDveJDdnnVt22p+TEGJoctgdNDnr6dZao3bMdrWVJ554gjVr1jBy5EiuvfZaFEWhoaEBr9dLUlIShYWF/OIXvyAYDKLrve2/duzYwUUXXYTH4yEjI4Oamhr27t3L1VdfjdfrJSUlhdraWgmAQoiBdXIYnLpoUkzGkZiccMaObXfa8KUnnvLfJPQJEX8WLlrIjKoZUT1m+AOtqqroun7CfvGG8UklJTwzGKaqamTWMBQKoWla5DEAhmHErPwLEgCFEEgYEkLEB4fDgcPhGJDnysjIoK2tjf3797NhwwbGjBkDwPvvv09JSQmlpaW8+eabuN1u6urqyM/Pp7CwkHfeeQer1UpjYyMjRowYkLGeimL2r0eEEEIIIYQ4zjRN1qxZw3PPPYfL5eL6668nISGB1atXc9NNN9HT08P9999PU1MT8+fPp7q6msbGRu6//35aW1tZtGgRc+bMidkHcAmAQgghhBBfQLj8C59UUsLl4L73CZeHT75/LKsvEgCFEEIIIYaZ2F19KIQQQgghYkICoBBCCCHEMCMBUAghhBBimJEAKIQQQggxzEgAFEIIIYQYZiQACiGEEEIMMxIAhRBCCCGGGQmAQgghhBDDjARAIYQQQohhRgKgEEIIIcQwIwFQCCGEEGKYkQAohBBCCDHMSAAUQgghhBhmJAAKIYQQQgwzEgCFEEIIIYYZCYBCCCGEEMOMBEAhhBBCiGFGAqAQQgghxDDz/wHQgMAbP36rzQAAAABJRU5ErkJggg==\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# 📋 Week 7 Compute distance, speed and heatmap participation for each player\n",
+        "\n",
+        "**Goal:** Deliver JSON stats for ISHITA'S Dashboard"
+      ],
+      "metadata": {
+        "id": "MQCFSrh0LvmR"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**🛣️ 3.1 Distance covered by each player**"
+      ],
+      "metadata": {
+        "id": "9SfjY5PlL4t_"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import numpy as np\n",
+        "\n",
+        "# Ensure previous row is player's previous location\n",
+        "df_sorted = df.sort_values(['player_id', 'frame_id', 'timestamp_s'],    # Sorts df so for each player_id the rows are in order of appearance in video(fram_id then timestamp_s)\n",
+        "                           kind='mergesort').copy()                     # mergesort an effective sorting alg. .copy() makes a copy rather than changing original\n",
+        "\n",
+        "# Defined oval dimensions from Flynns heatmappipeline.py file\n",
+        "field_length_m = 165\n",
+        "field_width_m = 135\n",
+        "\n",
+        "# Pixel range of field\n",
+        "px_width = df['cx'].max() - df['cx'].min()                             # Finds how many pixels are in the length of the field\n",
+        "px_length  = df['cy'].max() - df['cy'].min()                           # Finds how many pixels are in the width of the field\n",
+        "\n",
+        "scale_x = field_width_m / px_width                                     # How many meters per pixel i.e. 165 / 1000 = 0.165m per pixel\n",
+        "scale_y = field_length_m / px_length\n",
+        "\n",
+        "# Convert cx, cy into metres\n",
+        "df_sorted['cx_m'] = (                                                   # creating a new sorted series\n",
+        "    df_sorted['cx']                                                     # pd series of x-coordinates in pixels\n",
+        "    - df_sorted['cx'].min()                                             # smallest x-pixel coordinates\n",
+        "    ) * scale_x                                                         # e.g. (732 - 1) * 0.165 = 120.615m / 165m down the length of the field\n",
+        "\n",
+        "df_sorted['cy_m'] = (                                                   # Same again\n",
+        "    df_sorted['cy']\n",
+        "    - df_sorted['cy'].min()\n",
+        "    ) * scale_y                                                         # e.g. (721 - 40) * 0.165 = 112.365m / 135m across the width of the field\n",
+        "\n",
+        "# Step distances in metres\n",
+        "dx_m = df_sorted.groupby('player_id')['cx_m'].diff()                    # For each player compute difference between x positions in meters\n",
+        "dy_m = df_sorted.groupby('player_id')['cy_m'].diff()                    # For each player compute difference between y position in meters\n",
+        "\n",
+        "# compute distance travelled and clamp unrealistic speeds\n",
+        "# Using per frame distance. Anything >3 m between previous frames is treated as an outlier.\n",
+        "step = np.hypot(dx_m, dy_m)                                             # np.hypot() finds euclidean difference between x and y coordinates\n",
+        "max_step_m = 0.5                                                          # reasonable per-frame maximum at 50fps footage?\n",
+        "df_sorted['step_dist_m'] = np.where(np.isfinite(step) & (step <= max_step_m), step, 0.0) # Two checks: keeps only step data that is real (.isfinite) and under max step. If conditions true keep, if not replace with 0.0\n",
+        "df_sorted['step_dist_m'] = df_sorted['step_dist_m'].fillna(0)           # np.hypot() finds the euclidean difference between x-difference and y-difference. Fill Na's with '0'\n",
+        "\n",
+        "# Total distance per player\n",
+        "player_distance = (\n",
+        "    df_sorted.groupby('player_id', as_index=False)['step_dist_m']       # Group the df by player_id so all their rows are together\n",
+        "    .sum()                                                              # Sum all step distances for each player\n",
+        "    .rename(columns={'step_dist_m': 'distance_covered_m'})              # Clearer column name\n",
+        "    .sort_values('player_id')                                           # Sort the rows by player_id\n",
+        ")\n",
+        "\n",
+        "# Print results\n",
+        "for _, row in player_distance.iterrows():                               # Loop through each row of the summary df, iterrows lets you iterate through rows\n",
+        "    print(f\"player_id {int(row.player_id)}: {row.distance_covered_m:.2f} m\")"
+      ],
+      "metadata": {
+        "id": "_y5-MSbZMZDi",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "17ebbf74-d84f-477f-c87c-96c1fe4f763f"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "player_id 1: 3.60 m\n",
+            "player_id 2: 0.00 m\n",
+            "player_id 3: 0.00 m\n",
+            "player_id 4: 0.00 m\n",
+            "player_id 5: 0.44 m\n",
+            "player_id 34: 0.32 m\n",
+            "player_id 36: 0.00 m\n",
+            "player_id 45: 0.00 m\n",
+            "player_id 49: 0.00 m\n",
+            "player_id 50: 2.94 m\n",
+            "player_id 55: 0.00 m\n",
+            "player_id 62: 2.54 m\n",
+            "player_id 63: 0.00 m\n",
+            "player_id 64: 0.00 m\n",
+            "player_id 69: 0.00 m\n",
+            "player_id 70: 0.00 m\n",
+            "player_id 72: 0.00 m\n",
+            "player_id 73: 0.00 m\n",
+            "player_id 78: 0.00 m\n",
+            "player_id 79: 3.31 m\n",
+            "player_id 86: 0.24 m\n",
+            "player_id 87: 0.00 m\n",
+            "player_id 88: 0.00 m\n",
+            "player_id 98: 0.00 m\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**🚀 3.2 Mean Speed + Max Speed of each player**\n",
+        "\n",
+        "---\n",
+        "\n"
+      ],
+      "metadata": {
+        "id": "M5YeMTkVL-Oe"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "fps = 25\n",
+        "\n",
+        "# Time delta from frame gaps per player (more reliable than timestamp_s if jittery)\n",
+        "frame_gap = df_sorted.groupby('player_id')['frame_id'].diff()       # Groups data by player_id, finding difference between current frame and previous\n",
+        "dt_frames = frame_gap / fps                                         # Converts gaps between frames into actual time (seconds)\n",
+        "\n",
+        "# Instantaneous speed (m/s) from clamped per-step distance\n",
+        "clamped_step = df_sorted['step_dist_m']                                                         # Using clamped step distance from earlier (step_dist_m)\n",
+        "speed_mps = np.where((dt_frames > 0) & np.isfinite(dt_frames), clamped_step / dt_frames, np.nan) # Speed formula: speed (m/s) = distance (m) / time (s). Use NaN for invalids so mean ignores them.\n",
+        "\n",
+        "# Cap impossible speeds by clipping\n",
+        "vmax_ms = 12.0                                                                                  # Defining a maximum speed of 12 m/s (~43 km/h).\n",
+        "speed_mps = np.clip(speed_mps, 0, vmax_ms)                                                      # Clip speeds to [0, vmax_ms]. Keeps valid samples but prevents spikes.\n",
+        "\n",
+        "df_sorted['speed_mps'] = speed_mps                                                              # Stores clean speed values into df\n",
+        "df_sorted['dt_s'] = np.where(np.isfinite(dt_frames) & (dt_frames > 0), dt_frames, np.nan)       # Stores valid time gaps (s) into df. Invalids set to NaN.\n",
+        "\n",
+        "# Per-player summaries\n",
+        "player_speed = (\n",
+        "    df_sorted.groupby('player_id')\n",
+        "             .agg(\n",
+        "                 mean_speed_mps=('speed_mps', 'mean'),          # Mean of frame-by-frame speeds (ignores NaNs)\n",
+        "                 max_speed_mps=('speed_mps', 'max'),            # Peak instantaneous speed\n",
+        "                 total_dist_m=('step_dist_m', 'sum'),           # Total distance covered (m), already clamped\n",
+        "                 total_time_s=('dt_s', 'sum')                   # Total valid time (s)\n",
+        "             )\n",
+        "             .reset_index()\n",
+        ")\n",
+        "\n",
+        "# Print results (both m/s and km/h)\n",
+        "for _, r in player_speed.iterrows():\n",
+        "    print(\n",
+        "        f\"player_id {int(r.player_id)}: \"\n",
+        "        f\"mean_speed= {r.mean_speed_mps:.2f} m/s ({r.mean_speed_mps*3.6:.1f} km/h), \"\n",
+        "        f\"max_speed= {r.max_speed_mps:.2f} m/s ({r.max_speed_mps*3.6:.1f} km/h), \"\n",
+        "        f\"distance= {r.total_dist_m:.2f} m, \"\n",
+        "        f\"time= {r.total_time_s:.2f} s\"\n",
+        "    )"
+      ],
+      "metadata": {
+        "id": "dLZaOqlEMZsK",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "b06061e6-bc62-469a-e1fd-eb6fa5ba12aa"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "player_id 1: mean_speed= 0.48 m/s (1.7 km/h), max_speed= 12.00 m/s (43.2 km/h), distance= 3.60 m, time= 7.36 s\n",
+            "player_id 2: mean_speed= 0.00 m/s (0.0 km/h), max_speed= 0.00 m/s (0.0 km/h), distance= 0.00 m, time= 7.36 s\n",
+            "player_id 3: mean_speed= nan m/s (nan km/h), max_speed= nan m/s (nan km/h), distance= 0.00 m, time= 0.00 s\n",
+            "player_id 4: mean_speed= nan m/s (nan km/h), max_speed= nan m/s (nan km/h), distance= 0.00 m, time= 0.00 s\n",
+            "player_id 5: mean_speed= 0.16 m/s (0.6 km/h), max_speed= 10.93 m/s (39.3 km/h), distance= 0.44 m, time= 3.04 s\n",
+            "player_id 34: mean_speed= 1.32 m/s (4.8 km/h), max_speed= 7.93 m/s (28.5 km/h), distance= 0.32 m, time= 0.24 s\n",
+            "player_id 36: mean_speed= 0.00 m/s (0.0 km/h), max_speed= 0.00 m/s (0.0 km/h), distance= 0.00 m, time= 1.44 s\n",
+            "player_id 45: mean_speed= nan m/s (nan km/h), max_speed= nan m/s (nan km/h), distance= 0.00 m, time= 0.00 s\n",
+            "player_id 49: mean_speed= 0.00 m/s (0.0 km/h), max_speed= 0.00 m/s (0.0 km/h), distance= 0.00 m, time= 0.12 s\n",
+            "player_id 50: mean_speed= 0.56 m/s (2.0 km/h), max_speed= 12.00 m/s (43.2 km/h), distance= 2.94 m, time= 5.48 s\n",
+            "player_id 55: mean_speed= 0.00 m/s (0.0 km/h), max_speed= 0.00 m/s (0.0 km/h), distance= 0.00 m, time= 0.96 s\n",
+            "player_id 62: mean_speed= 0.58 m/s (2.1 km/h), max_speed= 12.00 m/s (43.2 km/h), distance= 2.54 m, time= 4.36 s\n",
+            "player_id 63: mean_speed= 0.00 m/s (0.0 km/h), max_speed= 0.00 m/s (0.0 km/h), distance= 0.00 m, time= 0.12 s\n",
+            "player_id 64: mean_speed= 0.00 m/s (0.0 km/h), max_speed= 0.00 m/s (0.0 km/h), distance= 0.00 m, time= 1.16 s\n",
+            "player_id 69: mean_speed= 0.00 m/s (0.0 km/h), max_speed= 0.00 m/s (0.0 km/h), distance= 0.00 m, time= 0.28 s\n",
+            "player_id 70: mean_speed= 0.00 m/s (0.0 km/h), max_speed= 0.00 m/s (0.0 km/h), distance= 0.00 m, time= 0.28 s\n",
+            "player_id 72: mean_speed= 0.00 m/s (0.0 km/h), max_speed= 0.00 m/s (0.0 km/h), distance= 0.00 m, time= 0.72 s\n",
+            "player_id 73: mean_speed= 0.00 m/s (0.0 km/h), max_speed= 0.00 m/s (0.0 km/h), distance= 0.00 m, time= 0.12 s\n",
+            "player_id 78: mean_speed= 0.00 m/s (0.0 km/h), max_speed= 0.00 m/s (0.0 km/h), distance= 0.00 m, time= 0.84 s\n",
+            "player_id 79: mean_speed= 1.49 m/s (5.4 km/h), max_speed= 12.00 m/s (43.2 km/h), distance= 3.31 m, time= 2.20 s\n",
+            "player_id 86: mean_speed= 0.86 m/s (3.1 km/h), max_speed= 6.03 m/s (21.7 km/h), distance= 0.24 m, time= 0.28 s\n",
+            "player_id 87: mean_speed= 0.00 m/s (0.0 km/h), max_speed= 0.00 m/s (0.0 km/h), distance= 0.00 m, time= 0.20 s\n",
+            "player_id 88: mean_speed= 0.00 m/s (0.0 km/h), max_speed= 0.00 m/s (0.0 km/h), distance= 0.00 m, time= 0.28 s\n",
+            "player_id 98: mean_speed= nan m/s (nan km/h), max_speed= nan m/s (nan km/h), distance= 0.00 m, time= 0.00 s\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**🏅 3.3 Heatmap Participation**"
+      ],
+      "metadata": {
+        "id": "tuGg7gH9MCtE"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# 3.3.1\n",
+        "\n",
+        "# Always work in /content so outputs are visible\n",
+        "%cd /content\n",
+        "\n",
+        "# Make sure output folder exists (neat, dedicated for fixed vmax runs)\n",
+        "!mkdir -p heatmap_frames_vmax\n",
+        "\n",
+        "import numpy as np, pandas as pd\n",
+        "from scipy.ndimage import gaussian_filter\n",
+        "\n",
+        "# df should already be loaded earlier in the notebook:\n",
+        "# df = pd.read_csv(\"tracking.csv\")\n",
+        "\n",
+        "# Sorted data\n",
+        "df_sorted = df.sort_values(['player_id','frame_id','timestamp_s'], kind='mergesort').copy()\n",
+        "\n",
+        "# Match pipeline settings\n",
+        "FIELD_LEN_M, FIELD_WID_M = 165.0, 135.0\n",
+        "NX, NY, SIGMA = 200, 150, 2.0\n",
+        "\n",
+        "# Shared bbox like the pipeline uses\n",
+        "px_xmin, px_xmax = df_sorted['cx'].min(), df_sorted['cx'].max()\n",
+        "px_ymin, px_ymax = df_sorted['cy'].min(), df_sorted['cy'].max()\n",
+        "shared_bbox_raw = (px_xmin, px_xmax, px_ymin, px_ymax)\n",
+        "\n",
+        "a, b = FIELD_LEN_M/2.0, FIELD_WID_M/2.0  # metres (half-length, half-width)\n",
+        "\n",
+        "def raw_to_metres(x, y, bbox, a, b):\n",
+        "    xmin, xmax, ymin, ymax = bbox\n",
+        "    xm = ((x - xmin) / max(1e-9, (xmax - xmin))) * (2*a) - a\n",
+        "    ym = ((y - ymin) / max(1e-9, (ymax - ymin))) * (2*b) - b\n",
+        "    return xm, ym\n",
+        "\n",
+        "def frame_heat_max(frame_df):\n",
+        "    # Confidence-weighted, same grid/smoothing as pipeline; return robust 99th-pct max\n",
+        "    w = pd.to_numeric(frame_df[\"confidence\"], errors=\"coerce\").fillna(0.0).to_numpy()\n",
+        "    x_m, y_m = raw_to_metres(frame_df[\"cx\"].to_numpy(), frame_df[\"cy\"].to_numpy(),\n",
+        "                             shared_bbox_raw, a, b)\n",
+        "    x_edges = np.linspace(-a, a, NX+1)\n",
+        "    y_edges = np.linspace(-b, b, NY+1)\n",
+        "    H, _, _ = np.histogram2d(x_m, y_m, bins=[x_edges, y_edges], weights=w)\n",
+        "    H = H.T\n",
+        "    Hs = gaussian_filter(H, sigma=SIGMA)\n",
+        "    finite = Hs[np.isfinite(Hs)]\n",
+        "    return np.nanpercentile(finite, 99) if finite.size else 0.0\n",
+        "\n",
+        "VMAX_GLOBAL = float(np.max([\n",
+        "    frame_heat_max(g) for _, g in df_sorted.groupby(\"frame_id\", sort=True)\n",
+        "]))\n",
+        "print(\"Global vmax for colour scale:\", VMAX_GLOBAL)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "I9euiH_SSA_o",
+        "outputId": "16c911d7-3a07-41e6-aea3-8e0fadbc1a22"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "/content\n",
+            "Global vmax for color scale: 0.003944370776504145\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# 3.3.2\n",
+        "\n",
+        "from pathlib import Path\n",
+        "import re\n",
+        "\n",
+        "p = Path(\"heatmappipeline_xuan.py\")\n",
+        "code = p.read_text()\n",
+        "\n",
+        "if \"--vmax\" not in code:\n",
+        "    # Insert new argument right after --sigma (keeps indentation safe)\n",
+        "    code = re.sub(\n",
+        "        r'(ap\\.add_argument\\(\"--sigma\".*?\\)\\n)',\n",
+        "        r'\\1    ap.add_argument(\"--vmax\", type=float, default=None,\\n'\n",
+        "        r'                    help=\"Fix colorbar upper bound for consistent scale across images\")\\n',\n",
+        "        code,\n",
+        "        count=1,\n",
+        "        flags=re.DOTALL\n",
+        "    )\n",
+        "    # Add vmax_override to the plotting function signature\n",
+        "    code = code.replace(\n",
+        "        'def plot_heatmap_on_field_metres(\\n    H, x_edges, y_edges, a, b, title=\"\", alpha_img=0.88, out_path=None\\n):',\n",
+        "        'def plot_heatmap_on_field_metres(\\n    H, x_edges, y_edges, a, b, title=\"\", alpha_img=0.88, out_path=None, vmax_override=None\\n):'\n",
+        "    )\n",
+        "    # Use override if provided\n",
+        "    code = code.replace(\n",
+        "        'vmax = (np.nanpercentile(finite_vals, 99) if finite_vals.size else np.nanmax(H)) or 1.0',\n",
+        "        'vmax = (vmax_override if (vmax_override is not None) else '\n",
+        "        '(np.nanpercentile(finite_vals, 99) if finite_vals.size else np.nanmax(H)) or 1.0)'\n",
+        "    )\n",
+        "    # Pass override through call sites\n",
+        "    code = code.replace(\n",
+        "        'plot_heatmap_on_field_metres(H, xe, ye, a, b, title, out_path=img_out)',\n",
+        "        'plot_heatmap_on_field_metres(H, xe, ye, a, b, title, out_path=img_out, vmax_override=args.vmax)'\n",
+        "    )\n",
+        "    p.write_text(code)\n",
+        "    print(\"Patched pipeline with --vmax\")\n",
+        "else:\n",
+        "    print(\"Pipeline already patched\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "QSyUKjlHSFiZ",
+        "outputId": "56bd3352-89b7-4e48-b4fe-526c8a70a8fd"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Patched pipeline with --vmax ✅\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# 3.3.3  Generate one heatmap per frame (temp CSVs saved neatly in a folder)\n",
+        "\n",
+        "import os\n",
+        "\n",
+        "out_dir = \"heatmap_frames_vmax\"   # where PNGs go\n",
+        "tmp_dir = \"tmp_frames_vmax\"       # where per-frame CSVs go\n",
+        "os.makedirs(out_dir, exist_ok=True)\n",
+        "os.makedirs(tmp_dir, exist_ok=True)\n",
+        "\n",
+        "unique_frames = sorted(df_sorted[\"frame_id\"].unique().tolist())\n",
+        "print(f\"Generating {len(unique_frames)} heatmaps...\")\n",
+        "\n",
+        "for fid in unique_frames:\n",
+        "    sub = df_sorted[df_sorted[\"frame_id\"] == fid][[\n",
+        "        'frame_id','player_id','timestamp_s','x1','y1','x2','y2','cx','cy','w','h','confidence'\n",
+        "    ]].copy()\n",
+        "\n",
+        "    tmp_name = f\"tmp_frame_{fid:05d}.csv\"\n",
+        "    temp_csv = os.path.join(tmp_dir, tmp_name)  # << save into folder\n",
+        "    sub.to_csv(temp_csv, index=False)\n",
+        "\n",
+        "    label = f\"frame_{fid:05d}\"\n",
+        "    !python heatmappipeline_xuan.py \\\n",
+        "      --inputs \"{temp_csv}:{label}\" \\\n",
+        "      --out-dir {out_dir} \\\n",
+        "      --weight-mode conf \\\n",
+        "      --field-length 165 --field-width 135 \\\n",
+        "      --nx 200 --ny 150 \\\n",
+        "      --sigma 2.0 \\\n",
+        "      --vmax 0.001"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "collapsed": true,
+        "id": "xNGYgBTVSL1F",
+        "outputId": "3f02e5cb-f910-4eca-9434-89effd75c36d"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Generating 193 heatmaps...\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n",
+            "DEBUG group-by: None\n",
+            "Done. Outputs in: /content/heatmap_frames_vmax\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# 3.3.4\n",
+        "\n",
+        "!ls -l heatmap_frames_vmax | head -n 12"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "0dwVrXpSSRKD",
+        "outputId": "1a5a924e-4397-4ee1-b996-c6fbb8613b0f"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "total 220552\n",
+            "-rw-r--r-- 1 root root 954466 Sep 13 12:06 density_frame_00001.csv\n",
+            "-rw-r--r-- 1 root root 954466 Sep 13 12:06 density_frame_00002.csv\n",
+            "-rw-r--r-- 1 root root 954466 Sep 13 12:06 density_frame_00003.csv\n",
+            "-rw-r--r-- 1 root root 954466 Sep 13 12:06 density_frame_00004.csv\n",
+            "-rw-r--r-- 1 root root 954466 Sep 13 12:06 density_frame_00005.csv\n",
+            "-rw-r--r-- 1 root root 954466 Sep 13 12:06 density_frame_00006.csv\n",
+            "-rw-r--r-- 1 root root 954466 Sep 13 12:06 density_frame_00007.csv\n",
+            "-rw-r--r-- 1 root root 954466 Sep 13 12:06 density_frame_00008.csv\n",
+            "-rw-r--r-- 1 root root 954466 Sep 13 12:06 density_frame_00009.csv\n",
+            "-rw-r--r-- 1 root root 954466 Sep 13 12:06 density_frame_00010.csv\n",
+            "-rw-r--r-- 1 root root 959648 Sep 13 12:06 density_frame_00011.csv\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# 3.3.5\n",
+        "\n",
+        "import imageio, glob, os, re\n",
+        "\n",
+        "# Collect the per-frame images from the neat folder\n",
+        "candidates = glob.glob(os.path.join(\"heatmap_frames_vmax\", \"heatmap_*.png\"))\n",
+        "\n",
+        "# Natural sort by trailing number (frame index)\n",
+        "def frame_key(p):\n",
+        "    m = re.search(r'(\\d+)(?=\\.png$)', os.path.basename(p))\n",
+        "    return int(m.group(1)) if m else 0\n",
+        "\n",
+        "pngs = sorted(candidates, key=frame_key)\n",
+        "print(\"Found\", len(pngs), \"frames for video.\")\n",
+        "\n",
+        "out_mp4 = \"heatmap_everyframe_vmax.mp4\"\n",
+        "with imageio.get_writer(out_mp4, fps=10, codec=\"libx264\") as w:\n",
+        "    for fn in pngs:\n",
+        "        w.append_data(imageio.imread(fn))\n",
+        "\n",
+        "print(\"Saved:\", out_mp4)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "mlYcPcMpSUky",
+        "outputId": "9b5f45cb-d5b7-4021-904d-0dd0210a5cb6"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Found 193 frames for video.\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/tmp/ipython-input-1322419623.py:19: DeprecationWarning: Starting with ImageIO v3 the behavior of this function will switch to that of iio.v3.imread. To keep the current behavior (and make this warning disappear) use `import imageio.v2 as imageio` or call `imageio.v2.imread` directly.\n",
+            "  w.append_data(imageio.imread(fn))\n",
+            "WARNING:imageio_ffmpeg:IMAGEIO FFMPEG_WRITER WARNING: input image is not divisible by macro_block_size=16, resizing from (2420, 1760) to (2432, 1760) to ensure video compatibility with most codecs and players. To prevent resizing, make your input image divisible by the macro_block_size or set the macro_block_size to 1 (risking incompatibility).\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Saved: heatmap_everyframe_vmax.mp4\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# 3.3.6\n",
+        "\n",
+        "from google.colab import files\n",
+        "files.download(\"heatmap_everyframe_vmax.mp4\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 17
+        },
+        "id": "kb0nHaksSY4M",
+        "outputId": "12ec3556-f18a-48e0-91de-f29173ba7474"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<IPython.core.display.Javascript object>"
+            ],
+            "application/javascript": [
+              "\n",
+              "    async function download(id, filename, size) {\n",
+              "      if (!google.colab.kernel.accessAllowed) {\n",
+              "        return;\n",
+              "      }\n",
+              "      const div = document.createElement('div');\n",
+              "      const label = document.createElement('label');\n",
+              "      label.textContent = `Downloading \"${filename}\": `;\n",
+              "      div.appendChild(label);\n",
+              "      const progress = document.createElement('progress');\n",
+              "      progress.max = size;\n",
+              "      div.appendChild(progress);\n",
+              "      document.body.appendChild(div);\n",
+              "\n",
+              "      const buffers = [];\n",
+              "      let downloaded = 0;\n",
+              "\n",
+              "      const channel = await google.colab.kernel.comms.open(id);\n",
+              "      // Send a message to notify the kernel that we're ready.\n",
+              "      channel.send({})\n",
+              "\n",
+              "      for await (const message of channel.messages) {\n",
+              "        // Send a message to notify the kernel that we're ready.\n",
+              "        channel.send({})\n",
+              "        if (message.buffers) {\n",
+              "          for (const buffer of message.buffers) {\n",
+              "            buffers.push(buffer);\n",
+              "            downloaded += buffer.byteLength;\n",
+              "            progress.value = downloaded;\n",
+              "          }\n",
+              "        }\n",
+              "      }\n",
+              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
+              "      const a = document.createElement('a');\n",
+              "      a.href = window.URL.createObjectURL(blob);\n",
+              "      a.download = filename;\n",
+              "      div.appendChild(a);\n",
+              "      a.click();\n",
+              "      div.remove();\n",
+              "    }\n",
+              "  "
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<IPython.core.display.Javascript object>"
+            ],
+            "application/javascript": [
+              "download(\"download_ca664532-bc75-4bc0-82d3-fa163dc8d63c\", \"heatmap_everyframe_vmax.mp4\", 254395)"
+            ]
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "🌊 **3.4 Speed Threshold Marker**\n"
+      ],
+      "metadata": {
+        "id": "yt5-r1hJJHCj"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Ensure speed_mps exists on df_sorted\n",
+        "if 'speed_mps' not in df_sorted.columns:\n",
+        "    # Use 25 fps for this clip (193 frames in ~7.68 s)\n",
+        "    fps = 25.0\n",
+        "\n",
+        "    # If metre coordinates exist from earlier, use them; else derive metres from cx,cy range.\n",
+        "    if {'cx_m','cy_m'}.issubset(df_sorted.columns):\n",
+        "        x = df_sorted['cx_m'].astype(float)\n",
+        "        y = df_sorted['cy_m'].astype(float)\n",
+        "    else:\n",
+        "        FIELD_LEN_M, FIELD_WID_M = 165.0, 135.0\n",
+        "        px_w = (df_sorted['cx'].max() - df_sorted['cx'].min())\n",
+        "        px_l = (df_sorted['cy'].max() - df_sorted['cy'].min())\n",
+        "        sx   = FIELD_WID_M / max(px_w, 1e-9)\n",
+        "        sy   = FIELD_LEN_M / max(px_l, 1e-9)\n",
+        "        x = (df_sorted['cx'] - df_sorted['cx'].min()) * sx\n",
+        "        y = (df_sorted['cy'] - df_sorted['cy'].min()) * sy\n",
+        "\n",
+        "    dx = x.groupby(df_sorted['player_id']).diff()\n",
+        "    dy = y.groupby(df_sorted['player_id']).diff()\n",
+        "    step_m = np.hypot(dx, dy)\n",
+        "\n",
+        "    dt_s = df_sorted.groupby('player_id')['frame_id'].diff() / fps\n",
+        "\n",
+        "    # Raw speed (no clamping for this section)\n",
+        "    speed_mps = np.where((dt_s > 0) & np.isfinite(dt_s), step_m / dt_s, np.nan)\n",
+        "    df_sorted = df_sorted.copy()\n",
+        "    df_sorted['speed_mps'] = speed_mps\n",
+        "\n",
+        "# Filter rows above threshold and export\n",
+        "threshold_kmh = 15.0\n",
+        "speed_kmh = df_sorted['speed_mps'] * 3.6\n",
+        "\n",
+        "df_fast = df_sorted.loc[speed_kmh > threshold_kmh, ['player_id','frame_id']].copy()\n",
+        "df_fast['speed_kmh'] = speed_kmh.loc[df_fast.index]\n",
+        "\n",
+        "# keep timestamp for context\n",
+        "if 'timestamp_s' in df_sorted.columns:\n",
+        "    df_fast['timestamp_s'] = df_sorted.loc[df_fast.index, 'timestamp_s']\n",
+        "\n",
+        "print(df_fast.head(10))\n",
+        "df_fast.to_csv(\"players_over_15kmh.csv\", index=False)\n",
+        "print(\"Saved: players_over_15kmh.csv  (rows:\", len(df_fast), \")\")"
+      ],
+      "metadata": {
+        "id": "-fpZijEGJGiM",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "1aa4f7fa-4a3a-48be-9e5b-8570253d9978"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "    player_id  frame_id   speed_kmh  timestamp_s\n",
+            "2           1         2  150.066176         0.04\n",
+            "4           1         3   57.086052         0.08\n",
+            "6           1         4  106.698493         0.12\n",
+            "8           1         5   39.341608         0.16\n",
+            "10          1         6   94.098187         0.20\n",
+            "12          1         7  361.786703         0.24\n",
+            "14          1         8  126.836078         0.28\n",
+            "16          1         9   44.446889         0.32\n",
+            "18          1        10   61.787793         0.36\n",
+            "23          1        12  144.252563         0.44\n",
+            "Saved: players_over_15kmh.csv  (rows: 733 )\n"
+          ]
+        }
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/26_T1/afl_player_tracking_and_crowd_monitoring/team_log.md b/26_T1/afl_player_tracking_and_crowd_monitoring/team_log.md
deleted file mode 100644
index e69de29bb..000000000