From 681be962ae7f4a18fb076e9f56b3d798bcc18048 Mon Sep 17 00:00:00 2001 From: Pepijn Date: Wed, 27 Aug 2025 14:58:34 +0200 Subject: [PATCH] initial commit --- notebooks/rlearn_evaluation.ipynb | 799 ++++++++++++++++ src/lerobot/policies/factory.py | 14 + .../policies/rlearn/configuration_rlearn.py | 127 +++ src/lerobot/policies/rlearn/evaluation.py | 601 ++++++++++++ .../policies/rlearn/modeling_rlearn.py | 902 ++++++++++++++++++ .../policies/rlearn/processor_rlearn.py | 126 +++ src/lerobot/policies/rlearn/rlearn_plan.md | 136 +++ src/lerobot/processor/tokenizer_processor.py | 11 +- .../scripts/annotate_dataset_rewards.py | 335 +++++++ .../annotate_dataset_rewards_optimized.py | 591 ++++++++++++ tests/policies/rlearn/test_evaluation.py | 188 ++++ tests/policies/rlearn/test_rlearn.py | 237 +++++ 12 files changed, 4063 insertions(+), 4 deletions(-) create mode 100644 notebooks/rlearn_evaluation.ipynb create mode 100644 src/lerobot/policies/rlearn/configuration_rlearn.py create mode 100644 src/lerobot/policies/rlearn/evaluation.py create mode 100644 src/lerobot/policies/rlearn/modeling_rlearn.py create mode 100644 src/lerobot/policies/rlearn/processor_rlearn.py create mode 100644 src/lerobot/policies/rlearn/rlearn_plan.md create mode 100644 src/lerobot/scripts/annotate_dataset_rewards.py create mode 100644 src/lerobot/scripts/annotate_dataset_rewards_optimized.py create mode 100644 tests/policies/rlearn/test_evaluation.py create mode 100644 tests/policies/rlearn/test_rlearn.py diff --git a/notebooks/rlearn_evaluation.ipynb b/notebooks/rlearn_evaluation.ipynb new file mode 100644 index 000000000..3f5103b2a --- /dev/null +++ b/notebooks/rlearn_evaluation.ipynb @@ -0,0 +1,799 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# RLearN Model Evaluation\n", + "\n", + "This notebook provides comprehensive evaluation of the RLearN (Video-Language Conditioned Reward Model) using:\n", + "\n", + "1. **VOC-S (Value-Order Correlation for Success)**: Measures whether per-frame rewards increase as successful execution unfolds\n", + "2. **Success vs Failure Detection**: Tests the model's ability to distinguish correct vs incorrect language conditions\n", + "3. **Live Reward Visualization**: Shows predicted rewards alongside video frames\n", + "\n", + "## Requirements\n", + "\n", + "```bash\n", + "pip install matplotlib seaborn plotly ipywidgets\n", + "```\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✓ Imports successful\n" + ] + } + ], + "source": [ + "import os\n", + "import sys\n", + "from pathlib import Path\n", + "\n", + "# Add src to path for imports\n", + "sys.path.append(str(Path.cwd().parent / \"src\"))\n", + "\n", + "import warnings\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import torch\n", + "\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "# Interactive widgets\n", + "\n", + "# Plotly for interactive plots\n", + "\n", + "# LeRobot imports\n", + "from lerobot.constants import OBS_IMAGES, OBS_LANGUAGE\n", + "from lerobot.datasets.lerobot_dataset import LeRobotDataset\n", + "from lerobot.policies.rlearn.configuration_rlearn import RLearNConfig\n", + "from lerobot.policies.rlearn.evaluation import (\n", + " RLearnEvaluator,\n", + ")\n", + "from lerobot.policies.rlearn.modeling_rlearn import RLearNPolicy\n", + "\n", + "print(\"✓ Imports successful\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Setup Model and Dataset\n", + "\n", + "Load your trained RLearN model and the dataset for evaluation.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using device: cpu\n", + "Loading dataset...\n", + "Dataset loaded: 10 episodes, 1175 frames\n", + "Features: ['observation.images.image', 'observation.state', 'action', 'timestamp', 'frame_index', 'episode_index', 'index', 'task_index', 'next.reward']\n", + "FPS: 10\n" + ] + } + ], + "source": [ + "# Configuration\n", + "DATASET_REPO = \"pepijn223/rewards_bc_z3\" # Change to your dataset\n", + "MODEL_PATH = \"path/to/your/trained/model\" # Change to your model checkpoint\n", + "DEVICE = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "NUM_EVAL_EPISODES = 50 # Number of episodes for evaluation\n", + "\n", + "print(f\"Using device: {DEVICE}\")\n", + "\n", + "# Load dataset\n", + "print(\"Loading dataset...\")\n", + "dataset = LeRobotDataset(\n", + " repo_id=DATASET_REPO,\n", + " episodes=list(range(10)), # Load first 10 episodes for evaluation\n", + " download_videos=True,\n", + ")\n", + "\n", + "print(f\"Dataset loaded: {dataset.num_episodes} episodes, {dataset.num_frames} frames\")\n", + "print(f\"Features: {list(dataset.features.keys())}\")\n", + "print(f\"FPS: {dataset.fps}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:root:Device 'None' is not available. Switching to 'mps'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setting up model...\n", + "Creating new model for testing (random predictions)\n", + "✓ Model ready on cpu\n", + " Parameters: 900,447,748\n", + " Trainable: 18,920,964\n" + ] + } + ], + "source": [ + "# Load or create model\n", + "print(\"Setting up model...\")\n", + "\n", + "# Option 1: Load trained model\n", + "if os.path.exists(MODEL_PATH):\n", + " print(f\"Loading trained model from {MODEL_PATH}\")\n", + " model = RLearNPolicy.from_pretrained(MODEL_PATH)\n", + "else:\n", + " # Option 2: Create new model for testing (will give random predictions)\n", + " print(\"Creating new model for testing (random predictions)\")\n", + " config = RLearNConfig(\n", + " model_name=\"google/siglip2-large-patch16-256\",\n", + " dim_model=512,\n", + " n_heads=8,\n", + " n_layers=4,\n", + " max_seq_len=16,\n", + " )\n", + " model = RLearNPolicy(config)\n", + "\n", + "model = model.to(DEVICE)\n", + "model.eval()\n", + "\n", + "print(f\"✓ Model ready on {DEVICE}\")\n", + "print(f\" Parameters: {sum(p.numel() for p in model.parameters()):,}\")\n", + "print(f\" Trainable: {sum(p.numel() for p in model.parameters() if p.requires_grad):,}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. VOC-S Evaluation\n", + "\n", + "Evaluate Value-Order Correlation for Success - measures whether predicted rewards correlate with temporal progress.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running VOC-S evaluation...\n", + "Evaluating VOC-S on 50 episodes...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Computing VOC-S: 100%|██████████| 10/10 [00:02<00:00, 3.82it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "VOC-S Results:\n", + " Mean correlation: 0.0000\n", + " Std correlation: 0.0000\n", + " IQM correlation: 0.0000\n", + " Episodes evaluated: 0\n", + "\n", + "==================================================\n", + "VOC-S RESULTS\n", + "==================================================\n", + "Mean Correlation: 0.0000\n", + "Std Correlation: 0.0000\n", + "IQM Correlation: 0.0000\n", + "Episodes: 0\n", + "==================================================\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# Create evaluator\n", + "evaluator = RLearnEvaluator(model, device=DEVICE)\n", + "\n", + "# Run VOC-S evaluation\n", + "print(\"Running VOC-S evaluation...\")\n", + "voc_results = evaluator.evaluate_voc_s(\n", + " dataset=dataset, num_episodes=NUM_EVAL_EPISODES, use_interquartile_mean=True\n", + ")\n", + "\n", + "print(\"\\n\" + \"=\" * 50)\n", + "print(\"VOC-S RESULTS\")\n", + "print(\"=\" * 50)\n", + "print(f\"Mean Correlation: {voc_results['voc_s_mean']:.4f}\")\n", + "print(f\"Std Correlation: {voc_results['voc_s_std']:.4f}\")\n", + "print(f\"IQM Correlation: {voc_results['voc_s_iqm']:.4f}\")\n", + "print(f\"Episodes: {voc_results['num_episodes']}\")\n", + "print(\"=\" * 50)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Detailed reward visualization" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Visualizing first 4 episodes...\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Detailed Episode Statistics:\n", + "================================================================================\n", + "Episode 0:\n", + " Language: place the white sponge in the ceramic bowl\n", + " Frames: 32\n", + " VOC-S (Spearman ρ): -0.0682 (p=0.7108)\n", + " Reward range: [0.157, 0.944]\n", + " Trend: → Flat\n", + "--------------------------------------------------------------------------------\n", + "Episode 1:\n", + " Language: move the arm in a circular motion\n", + " Frames: 32\n", + " VOC-S (Spearman ρ): -0.6763 (p=0.0000)\n", + " Reward range: [-0.611, 0.297]\n", + " Trend: ↘ Decreasing\n", + "--------------------------------------------------------------------------------\n", + "Episode 2:\n", + " Language: place the bottle in the ceramic bowl\n", + " Frames: 32\n", + " VOC-S (Spearman ρ): -0.6463 (p=0.0001)\n", + " Reward range: [-0.082, 0.988]\n", + " Trend: ↘ Decreasing\n", + "--------------------------------------------------------------------------------\n", + "Episode 3:\n", + " Language: drag the ceramic bowl in a circle\n", + " Frames: 2\n", + " VOC-S (Spearman ρ): 1.0000 (p=nan)\n", + " Reward range: [0.375, 0.423]\n", + " Trend: ↗ Increasing\n", + "--------------------------------------------------------------------------------\n" + ] + } + ], + "source": [ + "# Static visualization function that works well in VS Code\n", + "def get_episode_data(episode_idx, max_frames=32):\n", + " \"\"\"Extract frames, language, and predict rewards for an episode.\"\"\"\n", + " try:\n", + " # Get episode data\n", + " ep_start = dataset.episode_data_index[\"from\"][episode_idx].item()\n", + " ep_end = dataset.episode_data_index[\"to\"][episode_idx].item()\n", + " episode_length = min(ep_end - ep_start, max_frames)\n", + "\n", + " # Collect frames and get language\n", + " frames = []\n", + " language = None\n", + "\n", + " for frame_idx in range(episode_length):\n", + " global_idx = ep_start + frame_idx\n", + " frame_data = dataset[global_idx]\n", + "\n", + " # Extract image\n", + " if OBS_IMAGES in frame_data:\n", + " img = frame_data[OBS_IMAGES]\n", + " else:\n", + " img_keys = [k for k in frame_data.keys() if \"image\" in k.lower()]\n", + " if img_keys:\n", + " img = frame_data[img_keys[0]]\n", + " else:\n", + " continue\n", + "\n", + " if isinstance(img, np.ndarray):\n", + " img = torch.from_numpy(img)\n", + "\n", + " # Ensure CHW format\n", + " if len(img.shape) == 3 and img.shape[-1] in [1, 3, 4]:\n", + " img = img.permute(2, 0, 1)\n", + "\n", + " # Resize to expected input size (256x256 for SigLIP2) BEFORE stacking\n", + " if img.shape[-2:] != (256, 256):\n", + " import torch.nn.functional as F\n", + "\n", + " img = F.interpolate(\n", + " img.unsqueeze(0), size=(256, 256), mode=\"bilinear\", align_corners=False\n", + " ).squeeze(0)\n", + "\n", + " # Normalize to [0, 1] if needed\n", + " if img.dtype == torch.uint8:\n", + " img = img.float() / 255.0\n", + "\n", + " frames.append(img)\n", + "\n", + " # Get language\n", + " if language is None:\n", + " if OBS_LANGUAGE in frame_data:\n", + " language = frame_data[OBS_LANGUAGE]\n", + " if isinstance(language, list):\n", + " language = language[0]\n", + " elif \"task\" in frame_data:\n", + " language = frame_data[\"task\"]\n", + " else:\n", + " language = \"No language provided\"\n", + "\n", + " if not frames:\n", + " return None, None, None, None\n", + "\n", + " frames_tensor = torch.stack(frames)\n", + "\n", + " # Predict rewards\n", + " rewards = evaluator.predict_episode_rewards(frames_tensor, language)\n", + "\n", + " return frames_tensor, language, rewards, episode_length\n", + "\n", + " except Exception as e:\n", + " print(f\"Error processing episode {episode_idx}: {e}\")\n", + " return None, None, None, None\n", + "\n", + "\n", + "def visualize_multiple_episodes(episode_indices=[0, 1, 2, 3], max_frames=32):\n", + " \"\"\"Visualize multiple episodes in a grid layout.\"\"\"\n", + " n_episodes = len(episode_indices)\n", + "\n", + " # Create figure with subplots\n", + " fig, axes = plt.subplots(2, 2, figsize=(16, 12))\n", + " axes = axes.flatten()\n", + "\n", + " from scipy.stats import spearmanr\n", + "\n", + " for i, episode_idx in enumerate(episode_indices[:4]): # Limit to 4 episodes\n", + " if i >= len(axes):\n", + " break\n", + "\n", + " frames, language, rewards, episode_length = get_episode_data(episode_idx, max_frames)\n", + "\n", + " if rewards is None:\n", + " axes[i].text(\n", + " 0.5,\n", + " 0.5,\n", + " f\"Episode {episode_idx}\\nNo data available\",\n", + " ha=\"center\",\n", + " va=\"center\",\n", + " transform=axes[i].transAxes,\n", + " )\n", + " axes[i].set_title(f\"Episode {episode_idx} - Error\")\n", + " continue\n", + "\n", + " # Plot rewards\n", + " time_steps = range(len(rewards))\n", + " axes[i].plot(\n", + " time_steps, rewards, \"b-\", linewidth=2, marker=\"o\", markersize=4, label=\"Predicted Reward\"\n", + " )\n", + "\n", + " # Add expected progress line\n", + " expected_progress = np.linspace(0, 1, len(rewards))\n", + " axes[i].plot(\n", + " time_steps,\n", + " expected_progress,\n", + " \"orange\",\n", + " linestyle=\"--\",\n", + " linewidth=2,\n", + " label=\"Expected Progress (0→1)\",\n", + " )\n", + "\n", + " # Compute VOC-S\n", + " frame_indices = np.arange(1, len(rewards) + 1)\n", + " correlation, p_value = spearmanr(frame_indices, rewards)\n", + "\n", + " # Format title with key info\n", + " title = f'Episode {episode_idx} (VOC-S: {correlation:.3f})\\n\"{language[:40]}{\"...\" if len(language) > 40 else \"\"}\"'\n", + " axes[i].set_title(title, fontsize=10)\n", + " axes[i].set_xlabel(\"Frame Index\")\n", + " axes[i].set_ylabel(\"Reward\")\n", + " axes[i].legend(fontsize=8)\n", + " axes[i].grid(True, alpha=0.3)\n", + "\n", + " # Add trend indicator\n", + " trend = \"↗ Inc\" if correlation > 0.1 else \"↘ Dec\" if correlation < -0.1 else \"→ Flat\"\n", + " axes[i].text(\n", + " 0.02,\n", + " 0.98,\n", + " trend,\n", + " transform=axes[i].transAxes,\n", + " verticalalignment=\"top\",\n", + " fontsize=10,\n", + " bbox=dict(boxstyle=\"round,pad=0.3\", facecolor=\"lightblue\", alpha=0.7),\n", + " )\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + " # Print detailed statistics\n", + " print(\"\\nDetailed Episode Statistics:\")\n", + " print(\"=\" * 80)\n", + "\n", + " for episode_idx in episode_indices:\n", + " frames, language, rewards, episode_length = get_episode_data(episode_idx, max_frames)\n", + "\n", + " if rewards is None:\n", + " print(f\"Episode {episode_idx}: No data available\")\n", + " continue\n", + "\n", + " frame_indices = np.arange(1, len(rewards) + 1)\n", + " correlation, p_value = spearmanr(frame_indices, rewards)\n", + "\n", + " print(f\"Episode {episode_idx}:\")\n", + " print(f\" Language: {language}\")\n", + " print(f\" Frames: {len(rewards)}\")\n", + " print(f\" VOC-S (Spearman ρ): {correlation:.4f} (p={p_value:.4f})\")\n", + " print(f\" Reward range: [{rewards.min():.3f}, {rewards.max():.3f}]\")\n", + " print(\n", + " f\" Trend: {'↗ Increasing' if correlation > 0.1 else '↘ Decreasing' if correlation < -0.1 else '→ Flat'}\"\n", + " )\n", + " print(\"-\" * 80)\n", + "\n", + "\n", + "def show_episode_frames(episode_idx, max_frames=32, show_frames=[0, -1]):\n", + " \"\"\"Show specific frames from an episode alongside reward curve.\"\"\"\n", + " frames, language, rewards, episode_length = get_episode_data(episode_idx, max_frames)\n", + "\n", + " if rewards is None:\n", + " print(f\"No data available for episode {episode_idx}\")\n", + " return\n", + "\n", + " # Create figure\n", + " fig = plt.figure(figsize=(15, 8))\n", + "\n", + " # Reward curve (top half)\n", + " ax1 = plt.subplot(2, len(show_frames) + 1, (1, len(show_frames) + 1))\n", + " time_steps = range(len(rewards))\n", + " ax1.plot(time_steps, rewards, \"b-\", linewidth=2, marker=\"o\", markersize=4, label=\"Predicted Reward\")\n", + " expected_progress = np.linspace(0, 1, len(rewards))\n", + " ax1.plot(time_steps, expected_progress, \"orange\", linestyle=\"--\", linewidth=2, label=\"Expected (0→1)\")\n", + "\n", + " # Highlight selected frames\n", + " for frame_idx in show_frames:\n", + " actual_idx = frame_idx if frame_idx >= 0 else len(rewards) + frame_idx\n", + " if 0 <= actual_idx < len(rewards):\n", + " ax1.axvline(x=actual_idx, color=\"red\", linestyle=\":\", alpha=0.7)\n", + " ax1.plot(actual_idx, rewards[actual_idx], \"ro\", markersize=8)\n", + "\n", + " from scipy.stats import spearmanr\n", + "\n", + " frame_indices = np.arange(1, len(rewards) + 1)\n", + " correlation, _ = spearmanr(frame_indices, rewards)\n", + "\n", + " ax1.set_title(f'Episode {episode_idx} - VOC-S: {correlation:.3f}\\n\"{language}\"', fontsize=12)\n", + " ax1.set_xlabel(\"Frame Index\")\n", + " ax1.set_ylabel(\"Predicted Reward\")\n", + " ax1.legend()\n", + " ax1.grid(True, alpha=0.3)\n", + "\n", + " # Show selected frames (bottom half)\n", + " for i, frame_idx in enumerate(show_frames):\n", + " actual_idx = frame_idx if frame_idx >= 0 else len(frames) + frame_idx\n", + "\n", + " if 0 <= actual_idx < len(frames):\n", + " ax = plt.subplot(2, len(show_frames) + 1, len(show_frames) + 2 + i)\n", + "\n", + " # Convert frame for display\n", + " frame = frames[actual_idx].permute(1, 2, 0).cpu().numpy()\n", + " if frame.max() > 1.0:\n", + " frame = frame / 255.0\n", + " frame = np.clip(frame, 0, 1)\n", + "\n", + " ax.imshow(frame)\n", + " ax.set_title(f\"Frame {actual_idx}\\nReward: {rewards[actual_idx]:.3f}\", fontsize=10)\n", + " ax.axis(\"off\")\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "# Visualize multiple episodes at once\n", + "print(\"Visualizing first 4 episodes...\")\n", + "visualize_multiple_episodes([0, 1, 2, 3], max_frames=32)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Success vs Failure Detection Visualization\n", + "\n", + "Test the model's ability to distinguish correct vs incorrect language conditions.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "==================================================\n", + "DETECTION TEST - EPISODE 0\n", + "==================================================\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode 0 Detection Analysis:\n", + " Correct language: 'place the white sponge in the ceramic bowl'\n", + " Incorrect language: 'kick the ball'\n", + " Final reward (correct): 0.5151\n", + " Final reward (incorrect): 0.2494\n", + " Difference: 0.2657\n", + " Detection: SUCCESS\n", + "\n", + "==================================================\n", + "DETECTION TEST - EPISODE 1\n", + "==================================================\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode 1 Detection Analysis:\n", + " Correct language: 'move the arm in a circular motion'\n", + " Incorrect language: 'dance in place'\n", + " Final reward (correct): -0.4347\n", + " Final reward (incorrect): -0.4841\n", + " Difference: 0.0494\n", + " Detection: SUCCESS\n", + "\n", + "==================================================\n", + "DETECTION TEST - EPISODE 2\n", + "==================================================\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode 2 Detection Analysis:\n", + " Correct language: 'place the bottle in the ceramic bowl'\n", + " Incorrect language: 'wave your hand'\n", + " Final reward (correct): 0.1400\n", + " Final reward (incorrect): 0.0280\n", + " Difference: 0.1120\n", + " Detection: SUCCESS\n", + "\n", + "==================================================\n", + "DETECTION TEST - EPISODE 3\n", + "==================================================\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABjYAAAPeCAYAAACvDyPsAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3QmczdX/x/H3zDBjJ7tkS1mKCFFCi0qrKKUISUrJmn0t+5Z9K2u0aKFdpZ9KJmRLJCQRyi7b2Gb7Pz7n/u+Ya2sw4zvL6/l43MfMPd+7nHvnm77f7/uc8wmKjY2NFQAAAAAAAAAAQAoQ7HUHAAAAAAAAAAAAEopgAwAAAAAAAAAApBgEGwAAAAAAAAAAIMUg2AAAAAAAAAAAACkGwQYAAAAAAAAAAEgxCDYAAAAAAAAAAECKQbABAAAAAAAAAABSDIINAAAAAAAAAACQYhBsAAAAAAAAAACAFINgAwAu0iuvvKKgoKDL+p5btmxx7zl9+vTL+r5IuKefflpFixb1uhspgu3Htj/bfg0AAJDWXa5jfTtWtWNWcOx+ITh2B5DcEGwASFMHYee6LVmyRGlVu3btVKFCBeXMmVOZMmVS6dKlXWhz5MiRRH+v07/3bNmy6bbbbtMXX3yhtOqjjz7Sfffdp9y5cys0NFRXXnmlHn/8cX377bdedw0AAACX6ZykS5cuSm44dj8Tx+4AkHyk87oDAHA59enTR8WKFTuj/Zprrrng1+rRo0eyPAG5UMuWLVP16tXVtGlTZciQQT///LMGDRqk//3vf/rhhx8UHJy4Gfjdd9+txo0bKzY2Vn/99ZcmTJighx56SF9++aVq1aqltMI+/zPPPONOcG+88Ua1b99e+fPn144dO9wJU82aNfXjjz+qatWqSq0aNWqkJ554QmFhYV53BQAAwNNzkjJlyqhIkSI6duyY0qdPr+SCY3cfjt05dgeQ/BBsAEhTbHRNpUqVEuW10qVL524pXXh4+BltxYsXV4cOHbR06VLdfPPNifp+JUqU0FNPPRV3/9FHH9V1112nUaNGpYiTo+PHj7vRWZca+Lz22mvuxKht27YaPnx4wLJm3bt318yZM1PF/nU2ERERypw5s0JCQtwNAAAgLTnfOYkNNEpOOHb34didY3cAyQ9LUQHAWda1HTZsmEaMGOFGTWXMmNFNuf7111//s8bGN998o2rVqilHjhzKkiWLSpYsqW7dugU8Zvfu3WrWrJny5cvnTlzKlSunN99884y+HDhwwK35mj17dvd6TZo0cW1ns379etWrV88tJ2WvaSdKn3766UV/D/51Zs/1fonJlr6yqdybNm0KaD9x4oR69+7tZtPYqKBChQqpU6dOrt3vkUcecctoxWcjyOzvEv/z//TTT67NRpaZ/fv3u+CmbNmy7u9k0+rtBPOXX34JeK3vv//ePW/WrFluhk7BggXdcl2HDh1y2z/++GM3us6+c/tpo7USwkbiDRw4UKVKlXL72tlqtdiIqMqVK8fd//PPP/XYY4/FLRlmgdPpywD4+/v+++/r1Vdfdf3NmjWr2zcOHjzovjs7GcubN6/73DZLJ/73aez5L730kt5++223/9pnq1ixopu9E5+N2HvxxRfdY+y/kVy5crn+nb7mrn/JhQULFrjH23tfddVVAdviP2f58uXuJNn2CXtdG81oo+NOP7l6+eWX3T5h+4b1wb5HG0l3ts/i/zvZY6+//np99dVXCfo7AQAAeF1jw84H7Ljt77//Vp06ddzvefLkccey0dHRAc+34yGbMWDHZXYcZcdwH374YaL2kWN3jt05dgeQXKTOOBkAzsEOEPfu3XvGAZQd2MU3Y8YMHT58WC1btnSjfGxE0p133qk1a9a4QOJs1q5dqwcffFA33HCDm15uB2J//PGHm5Ic/6D49ttvd+120GYHfh988IE7YbEQoU2bNu5xdpD38MMPu9kULVq0cCcQduBt4cbZ3vfWW291B8K2NJaNprGDYzvxmT17turWrfuf30tUVJR7/5MnT7oAx04E7KA6/sF5Uv5N/v33XzdLxC8mJka1a9d2n/+5555zn9++ewubfv/9d3ewa2wJrU8++cSdrNgJjn1v9n3biKyFCxe61zD2u7XZ9+Q/0bDXsIN5+xvs2rVLr7/+uguwfvvtN7dWbnx9+/Z1I73shMpOJuz3efPmxY1YsxOdffv2uZMN/4H/+djnshM0O1FJyKgn65+dpB49elStW7d2+6uFYfb57GT19L+x9cdOLGx/sH1tzJgxbkkD+w7su7ZQzurK2MmJff5evXoFPN9OZN577z33XrYfjx8/Xvfee6+bwWMnGf4lzBYtWuSmo9tnthMcW5rA9m/7Du0ELj47MbKTcHsvO7k5Gwv97rnnHvc467sFeva6c+bMiXuM/Y3tc3/33XcuICxfvry+/vprdezY0Z3w2z5y+ndtz7f3t3169OjR7u+2devWM/67BwAA8OqcxC4Mn4sFGHbxuEqVKu6CsC0ZazMI7Pj5hRdeiHucnbPYcVLDhg3dcb1d4Lfj3c8//1wPPPBAovWdY/fz49idY3cAl0ksAKQB06ZNs+EgZ72FhYXFPW7z5s2uLWPGjLHbt2+Pa//pp59ce7t27eLaevfu7dr8RowY4e7v2bPnnP0YOXKke8xbb70V13by5MnYW265JTZLliyxhw4dcm0ff/yxe9yQIUPiHhcVFRVbvXp1126fx69mzZqxZcuWjT1+/HhcW0xMTGzVqlVjr7322gR9P4sXLw74TkqWLBn73XffxSY2e+1mzZq572j37t2xy5cvj7333ntd+9ChQ+MeN3PmzNjg4ODYhQsXBjx/4sSJ7rE//viju79s2TJ3f+7cue7+6tWr3f3HHnsstkqVKnHPq127duyNN94Yd9++q+jo6IDXtr+97Qt9+vSJa7PvwF7v6quvjj169GjA48uXLx9boECB2AMHDsS1zZs3zz2+SJEi5/0eRo0a5R730UcfJeh7a9u2rXt8/O/j8OHDscWKFYstWrRo3Gfx97dMmTJuv/J78sknY4OCgmLvu+++gNe1/e70vvr3Afvb+P3111+xGTJkiK1bt25c2+nfR/z9aMaMGWf8t1etWjW3D8fn32bfvbHvw+7b3/Vc/P9t9OvXL6C9Xr167jP+8ccfAZ8lNDQ0oO2XX35x7WPGjDnnewAAAFzuc5L45yLxj/WbNGni2uIfoxo7tq1YsWJA2+nHZ3Y8aMeFd955Z0C7Hf/Z6/4Xjt19OHYP3MaxO4DkgqWoAKQp48aNc8tFxb/5pzjHZ7MdbAaEn81csBFSc+fOPedr2wgVY6OQbNTS2djzrcjck08+Gddmo3FsdM2RI0fcaBv/42yN1vgjsGx0UKtWrQJez0YOffvtt3r88cfdDBMb+WU3G4Fko7o2btzoRsL8Fxu5ZN+FjYSyKeM268P6kxSmTJniRvXYtGZbMmv+/PnuPa0An5/NYrGRXjbd2/+Z7GazZoyN+DFWuM+mZfunWtvoLhuBZAUOV65c6UZJ2TGyjfyxEWJ+NpLJv86ujYCz78u/dJg973Q2U8ZGUflZkcBVq1a5dlsqLH5xRfsu/4t/OryNQkoI2x9sH7RlzvysvzYizkZF2Sir+Ozzxy86afuuv+BhfNa+bds2N2MnvltuucVNYfcrXLiwm0Fko6v8Sx7E/z4iIyPdd2hLD9h/B2f7Dps3b/6fI9z8/w3ZqEJ7zXN9F/Y69t9MfDa93T7j6f8933XXXQEjCm1GlY0QtJF/AAAAyeWc5L/YLO747Nj29OOZ+MdnNtLfZlfY4852bJZQHLtz7H4uHLsD8BpLUQFIU+wAMyHFw6+99tqzFs6zJZ7OpX79+po8ebKeffZZNxW3Zs2abh1ZWyPVfyBua5vaa59evM5OBPzb/T8LFCjgDoDjs4P3+Gyqsh0Q9uzZ093ONUU4fkhzNnawaAeRxg6C33nnHffTDnKtBsi57Ny5M+C+nSjEP2g+G3tdW4bLpsfblOgBAwa4k5j434kFMuvWrXMnUef6TMYOku1A3k6KjP20kyA7ibCDeJuybUuHWQAU/+TIgiebqm/TtDdv3hywPvHZpjjblO/4/H+ns+0n5zrBOv37NhZGJYS9n53InC7+fuOfZu4/mYnPfwJn69qe3m7fhZ30xv/c59r/7e+0Z88eF8751xqeNm2aC8/ir5Frr/df3+HZ2HICNtXc1hi2aek2Nd5CxgYNGrgTWv9nteUGTj+xPP2/oXN9F+aKK65wJ/sAAADJ+ZzEz+omnH5cfLbjGbvA3K9fP3cRP34thrPVhEgojt05dj8Xjt0BeI1gAwASiV3Qt9FHNiLJCsNZkTNb69RGKtmarglZj/VC+WeG2PqxNkPjbGwkzoWyQMYK4Nm6vOcLNix8ic8OlK1eyPnYqCx/iHL//fe79YTtZOmOO+5w7+v/XFYccPjw4Wd9jfgH+XYi1L9/f1cLxU6Ounfv7kYP2cmC3ffXRIl/cmQnZBYE2SgoW4PXivrZyZmtm3u22Tb/FdZcKBvNZmztYTv4T2zn2tfO1X564b6EsNlD9ve278xOUO1Ey06abd3ei/0O7fm27rCd1H722WdulJn9jWwNaWs7PehLiMT8zAAAAF5IyHmEv0ZFjRo1XABgx+k2C8CO12zQ0sXi2J1j93Ph2B2A1wg2AOAsbNTR6azwXdGiRc/7PDvAtpkadrMDezsIt4N1CzvshKBIkSJavXq1O3iMP8pp/fr17qdt9/+0ad62HFT8A8INGzYEvN/VV1/tftpJi/+EIzHYCC//aKDzOX3a/PXXX3/B7/X888+7ET5WsNwK6dkBsk0//uWXX9z3+F8jzOykx0aQvfvuu270kf8kyE7q/CdHNmIpftF3OwC3kzGbWh+fFVA/X+FGP//f6Wz7yel/o7OxEzobeWR97tat23+erNr7ne11T99vknr/t6KC/pF49h3adH47cfGzE1T7Di/VzTff7G520msn4lYA00I2mw1ln9UKZtqIufgjv5LquwAAAEgJZs+e7WZ22MVl/2h5YxezExPH7hy7n45jdwBeocYGAJyF1ZqIX5ti6dKl+umnn3Tfffed8zk2Zfp05cuXdz/9U8FtlJMt32QzOfxsjdQxY8a4AMOm8/ofZ+0TJkyIe5xNubbHxWdr3dqU39dff92tHXs6m3p8PnYge7b1UG1JLfNfU+QtTIl/O30GR0JYLRFbY9Wmr1t9EmM1Q+z7nzRp0hmPt2nUERERcfdtmrcFO4MHD3ajt/zhip0k2Ughq1sSf8SXsZOR00f92NrACalHYuxz2t/2zTffDAh/LOg5fc3cs7GTjM6dO7vPbD/PNgLprbfecvudf3+w3xcvXhy33b6DN954w4VtCVkb+ELY+8Sfkm9r+drf5p577ok7kTvbd2j7Z/ylAS6UTTE//TXP9t+QvcfYsWMDHmcn2HYifb7/RgEAAFIrOzazY6H4x2JWz8HOaxITx+4cu/tx7A7Aa8zYAJCmWHEy/+iQ+KpWrRo3+8G/fJONzLHi3XZQNnLkSLeOqRXKO5c+ffq4pageeOABN/LE1pK1aeA2fdtfOM4KxlkIYcs1rVixwh3Y2uiZH3/80b2HfxTLQw89pFtvvdXV6rATEjv4nTNnzllnUFjxQXt9m/5tRd7sc+zatcsd4G7fvt2NnjqX77//3hVyszogtjarjZ6ykVL2XhZqPPXUU7oc7Pvo1auXO8Gx6d22DJbVM7EiiTbbxb4LOyC2v52120g0f+hiJxpWLM9OhOx7848Ss1FfdgJht9NPjh588EH392ratKn729u08rfffjtgH/gvtkat/a3tu7cp1xZs2cmBnZwlpPB6x44dtXbtWjdqyj6j/Q1s/VsLvuwE1E6GFi1a5B5r+4GNELMDf/t72UmgnZjZGsM2Ou/0mi2XypYCsKXN7L1sxJ/tx8bWz43/Hc6cOdNNY7f90/Y3G411tnWOE8o+k72Xjf6zkX82sstOkG1dYzspMvY3thF7NhPK/tuwpdJsqTc7ebOp9fGLDQIAAKQVdlxqM8bvvfdeV+PAzkXsPMHOa2zGeGLi2J1jd8OxOwCvEWwASFPsAPxsbIp2/APjxo0buwNOCxvspMAK/Nkok/PNSLA1be1gberUqdq7d6+bFm0zMOyA0l8AztYqtTDBDnbtQPDQoUOuYN3ptSnsvT/99FN3sGejf+yA317fDqRvvPHGgPe1A9Ply5e795k+fbr27dvnZnLY4871ef0sDLEDTTuwtBkfNuLGDi7teXbwHhoaqsvBvhdbq/eVV15x34/NQrETBBvJM2PGDH300UfuJMj+Rm3atHHT0+Pzj/DyB0jGTjTsRM4KrJ9+cmRTyO2kyaZK2+yZChUquLoo9ndJKDtptJFiNg2/a9eu7nuzv6N9l/YZ/ov9je2zWUFGG701bNgwtz/YdHE7sRsyZIhb/9bYVHw7UbIRYnYCZtPGb7jhBreWrZ2gJTbbb+29bZ/aunWr28ds37L39LMCjjbyy04qrT92AmsnR+eq9ZLQ97WTQpu6buGc/Xdj/+3Ze/gLGPr/27B91P529p1bQDh06FA3ehAAACAtsrp+tlTToEGD3DmEHTtZ8GDnJ4kdbHDszrG7/305dgfgpaBYKvAAQBw78LeDMDvQsoLcQFpjIVrLli3PmC4OAAAAIHnh2B1AWkaNDQAAAAAAAAAAkGIQbAAAAAAAAAAAgBSDYAMAAAAAAAAAAKQY1NgAAAAAAAAAAAApBjM2AAAAAAAAAABAikGwAQAAAAAAAAAemjVrlipUqKCMGTMqZ86cqlevnjZt2pSg50ZHR6tq1aoKCgpyty5dusRtO3bsmB555BEVLVrUvXa2bNlUunRpde/eXcePH4973GeffaY6derEPS5fvny65557tGDBgiT5vMClYimqyyAmJkb//POPsmbN6v5xAQAAANIyOwU5fPiwrrzySgUHp92xVpwnAAAAM2PGDLVq1cr9XqRIEf377786dOiQ8uTJox9//NGFDOczYMAADR48OO5+27Zt9eqrr7rfDxw4oGuuuUaFChVyocaOHTu0a9cut61p06YaOXKk+/2FF17QO++8o4IFCyp79uxat26dO2YLCQnRV199pcqVKyfhNwBc+HkCwcZlsH37dvePBwAAAIBTtm3bpquuukppFecJAAAAwMWdJ6Q771YkChuB5f+DWDLq1WiwPXv2uKQ3LY+KS8vYB2DYD8A+APYBJIf9wEYg2gV9/3FyWpUczhMAAIC3lixZolq1arnfp0yZ4pagMrYs1HfffafixYtr5cqV5zymqlatmluKymZ22GyP02ds+L300ktau3atmy26c+dO1/bMM89oxIgRZ33t/fv3q1ixYu731q1bq2/fvon4qYFLP08g2LgM/NPK7WTFy2DD1s2z9+ciRtrEPgDDfgD2AbAPIDntB2l9+aXkcJ4AAAC8ZQGCnwUT/mMCWxLKP8PzXMcJLVu2dAMkLAApXLhwXHtYWNgZz/n9998DApKGDRtq4sSJSp8+/Vlfe/To0XGv1bx5c45VkOzOEzibBQAAAAAAAIBk5L+qB3z00Ud666231K1bN9WoUSNBM0NsYMvChQtd/YK33377nLMw+vTpo549e7rQw+p/lClT5qI/B5BUCDYAAAAAAAAAwAPx623t3r37jN/jz8SI75dffnE/hw8frixZsribn7WdrT6Bzb6wpavq168fV3T86NGjcdsjIyNdQfHevXu71/vkk0/0+OOPJ8rnBBIbwQYAAAAAAAAAeOCmm25Srly53O+zZ892P60Ohs2wMPfee6/7WapUKXcbO3ZswPMtmIiIiHC3+AHFkSNH3O/z588PWILK2n/44Qf3u9XmsFkc5uDBg7rvvvs0ffp0twyWzeyw+0ByRY2NZMT+MbF/eJJqHWV7bfvHivW00yYv9gGbshgSEnJZ3gsAAADAf5s1a5aGDBmidevWKWPGjLrzzjs1ePBgV5w2Iees1atX1+LFi939zp07a9CgQXFrwPfr188Vr7Xf7dyjaNGievrpp9WmTZu4NdxthPHLL7+sX3/91a0rb8VBr7nmGj3//POuiC0ApDWhoaFu5oT9O2jBxtVXX619+/bp8OHDyp07t7p06eIet2HDBvdz79697ucrr7zibmerSxD/32cLKKyQeJ48edwSVH/++ad7bfPQQw8pZ86c7vdOnTq5EMQ/s6NFixZxr1uhQgWNHz/+MnwbQMIRbCSTNfN27typAwcOJOl72IVt+4crrRdpTKu82gdy5Mih/Pnzs98BAAAAHpsyZYqeffZZ93uxYsXchTO7iGYXvSxwsOP287E11/2hxun++OMPvf76627pEgsq7MLZ2rVr1bFjR/e7/4LY5s2b9dNPP7mlV2xE8MaNG7V06VJ3y5Qpk5544okk+OQAkLw999xzypw5s4YNG+aC5wwZMuiRRx5x4YSFEZfi5ptv1u23367ffvvN/btsoUW5cuX06KOPun+j/U6cOBH3u/27bTc/6w+Q3ATF/lclGlyyQ4cOKXv27G5KV7Zs2c7YvmPHDhdq5M2b1x3IJcUFYPszR0VFKV26dFxgTqMu9z5g72fTIW1NSAs3ChQokOTvif9m4Zb9TezfG2ZvpU3sA2AfQHLYD/7r+Dit4HvA5XTy5EkXJNhIX7uY9eGHH7qlTmxZExv81KpVK40ePfqcz1+0aJErTmvPff/9988YEbx69WoXTjRq1MhdNPv3339VsWJFF2TY/m37ub8fNnvDf06yadMmF4SYl156SWPGjLkM3wYAAEjpx8fM2PCYTeX1hxr+9fSSAsEGvNgHbGq78V84YVkqAAAAwBvLli2LW77Ewgljo4BtJO8333yjr7766rwXGZ566in3eJuV4Q824rvhhhvcze+KK65QmTJlXLBhQUf8JVcs3LCQxJarspkeflbQFgAAICEINjzmr6lhMzWA1Mi/b9u+TrABAAAAeGPbtm1xv9ugI798+fK5n1u3bj3nc1u2bKm//vpL3333nZuNnRC2Fvy3337rfm/evPkZs8ZsOSo/G3z12muvqX79+hfwiQAAQFrG+gPJBLMokFqxbwMAAADJ13+tTv3RRx/prbfeUrdu3dwsi4TODrntttsUERHh1oi3orXx2Vrt9r42E2T69OnudytaO3fu3Ev6LAAAIO0g2AAAAAAAIJWzYt1+tlTs6b8XLlz4rM+zouJm+PDhrjC43fys7aqrrgp4/CeffOKK1O7atcsVw7Vlq2xGxtlkzZpVTZo0cUtYWdHafv36XeKnBAAAaQXBBgAAAAAAqdxNN90UV9dx9uzZ7qcVD1+yZIn7/d5773U/rZi43caOHRvw/KNHj7oZGHbzs+Vmjxw5End/1KhRbobGsWPHNHjwYFeP4/TlaN9++239/fffcfd///33uDob8V8bAADgfAg2cEl27typVq1a6eqrr3YF4WwU0EMPPaT58+crObJpzglZEzahjwMAAACAlMCKdg8YMCAu2LBzuNKlS+vw4cPKnTu3unTpElcbw27+QuOvvPKKWyoq/s2vc+fOOnDggPt98eLFatu2raufYbM65syZ4wqT+287duxwj5s0aZI7byxatKjKli2r66+/3vXB2OwNAACAhKB4OC7ali1bdOutt7oAYOjQoe6g1EbsfP3116643Pr16y/qdU+ePOkOuk9nr50+ffpE6DkAAEAaZcWB7WJlTIzS7d8v5cwpBQdLuXPbOjRe9w5AErOloTJnzqxhw4Zp3bp1rtaFzbAYNGiQrrzyykt6bVtKys+CivjFweNvf/jhh90sj02bNmn79u1uOSpbisoKjD/11FOX1AcAAJB2MGMjFZmzbo7KTSynjP0yup92Pym9+OKLrjD00qVL9eijj6pEiRJutE379u3jpjObrVu3uoNXG7WTLVs2Pf744269VT8bAVS+fHlNnjxZxYoVcwfXxl57woQJql27tjv47t+/f9yarRUqVHCPs1FGVoguKioq7vVsxNDzzz+vfPnyuceUKVNGn3/+ub7//ns1bdpUBw8edK9tN3vvi/HVV1+pWrVqLtSx6dwPPvigOzCPH/rY69sopTvuuEOZMmVSuXLl3Cim+PyjlWx73bp13Rq18WeKPP3006pTp07Ac2wUlK1Zm9C+mEWLFunGG290Jw02Bf3jjz92/Vu1alXcY3799Vfdd9997u9k312jRo3iRmkBAIBUEmqULClVrKjgm25S7lq13E+779ptO4BUr2HDhvr55591/Phxd+5kszeuvfbauO3+WRnnO1fyP8YCET87Rzl9Zkf8m83QMO3atdPy5cv177//uvM4+7lgwQJCDQAAcEEINlIJCzEeff9Rrdm1Rsejj7ufdj+pwo39+/e7C+o2M8NCh9P5L87bNGQLNezxdrD6zTff6M8//1T9+vUDHm9rqtoBtQUB8S+228G0XfBfs2aNnnnmGS1cuFCNGzdWmzZt9Ntvv7k1W23ZKH/oYe9nF+d//PFHvfXWW+4xdrBt67pWrVpVI0eOdOGKTYO2W4cOHS7q89varxbg2AG5LbsVHBzs+mnvH1/37t3de9hnsuDnySefjAthrI8tWrRwn8W233333XGfIzH7cujQIbc8mM2osVFTffr0cVPG47MTmjvvvNOFH/Y69re18MlCKAAAkErYgIXjx8++zdoZ0AAAAAAghWApqmSq0huVtPPIzgQ/fleEbwZErGIDftb/sL7yZc6X4NfJnyW/lj+3/D8fZ0GEjbqxonLnYxfaLZTYvHmzm5lgZsyY4WZ2LFu2zM0e8C8/Ze158uQJeH6DBg3cLAs/Czds7Vf/2qs2Y6Nv377q1KmTevfurf/9739uBolNq7Ygwf8Yv+zZs7uZCvnz59elsBkq8U2dOtX13YIUmyHiZ6HGAw884H63mSX2ue27s+9tzJgxLoTxhyvWX5tZYbNLErMv77zzjvvMb7zxhtKlS+emeVuRQJvq7WeFAS3U8K+5638d+5tZMT//dwkAAFKwkye97gEAAAAAJAqCjWTKQo2/D/99ya8TFROVKK9zuvgF487HAga7OO4PNcx1113nZnTYNn+wUaRIkTNCDVOpUqWA+7/88oub6RB/ZkN0dLSbRn306FE38+Gqq65K8gvxGzduVK9evdwMCFuuyT87wpbdih9sWIjgV6BAAfdz9+7dLtiwgnw2syK+ypUrX3Cw8V99sfexftiyXP7ZIvY+p3+v3333nVuG6nS2rBXBBgAAKZjNxpgyRerTx+ueAAAAAECiINhIpmzmxIWwGRsWYpwuXXC6C56xkRC2BqvNArjYAuGnO9tyVmdrtyJzNvPBCtydzi7cZ8yYUZeDLe1kYYzVyLAiexYmWIhgM0/ii1/s3L4vc/pyVedjy0qdHiJZEfWL6cv52PdqrzN48OAztvkDGQAAkMIcOyZNnizZGvj//ON1bwAAwIV46CGvewAgrfrsM6UEBBvJVEKWgzpbjY0gBbllqPw/36/3vuqWrusujttofVuKyH+B/VLkzJlTtWrV0rhx49S6deszAgir2WCzMkqXLq1t27a5m3/Whi2RZNtt5saFsqLhNgPhmmuuOet2m5mwffv2cy6fFBoa6mZ4XIp9+/a5PliQUL16ddcWHh5+wa9TsmRJtxxXfKfft1ksVtQ7PpuV4g9MEtIXex+rN3LixAlXa+Rs72Pfq9U4sYJ+to8AAIAU7OhR6Y03JBuwsDPhS5sCAAAAQEpB8fBU4pHSj2j247N1Q74blCFdBvdzzuNzXKiRVCzUsJDAljWyi+K2JJItLzV69Gjdcsst7jF33XWXK1rdsGFDrVy50tW/sOLft9122xnLTCWELblktThs1sbatWvd+82aNUs9evRw2+11a9So4epOWKFyq+3x5ZdfumLYxi7c2+wEq/1hyzbZ8lXnYp/NQoT4N3u/K664Qrly5XI1K6xexrfffuuKd1+oVq1aae7cuRo+fLj77qwQuvU1fvBkBb2tmLd9ZnuM1RGJH3QkpC9Wp8RmcTz//POu/19//bWGDRvmtvnfy4rAW4F3K25uoYctP2WPs/omlxoEAQCAyyQiQnrtNSswJrVrFxhq1KkjffGFTXE9+3OtPXfuy9ZVAAAAALgUBBupLNxY1WKVjnU/5n4mZajhL8ptYcUdd9yhl19+2S1/dPfdd7vQYMKECXEXzj/55BN3Ad4CBws67HnvvffeRb2nzRKxGhTz5s1z9TluvvlmjRgxwi3F5Gchi22zi/Q2K8QKi/svzletWlUtWrRQ/fr13WyIIUOGnPO9LACxgtrxb7Zcky0PZWHKihUr3Gdu166dhg4desGf5dZbb9XEiRNdsFGuXDkXvthr2ZJa8T9vz5493Wewz3T48GEXDPklpC/ZsmXTZ5995oIZew0LgSwgMv73siWsrHaJfU/33HOPC6Patm3rZt3YewAAgGTsyBHJjmmKFZM6dJB27Tq17dFHbbqn9NFH0v33Sxs2SCtWKGbZMu39+mv30+679sKFvfwUAAAAAJBgQbEJrQKNi3bo0CFlz55dBw8edBeZ47Oi1zaroFixYgEXtBNbYi9FhaTRvHlzV7dk4cKFSboPvPPOO242hu2TSV2X5HLt40gYm71jBezz5s1LaJVGsQ+AfSAVOXTIptD6Zmns23eq3Y71HntM6tlTKlMmWe4H5zs+Tkv4HgAA50SNDQBpsMbGoQs4PmYxfcBDtiSUzXKxGiW2DNWbb76p8ePHJ/r72FJWFizky5fPLeHVuXNnPf7445et2DoAAEhEBw9KY8ZIw4dL//4bGGg88YRkS3ReRC0zAAAAAEgpCDYAD1nNEVsOy5aYsiW6rD7Js88+m+jvs3PnTrf8lP0sUKCAHnvsMfXv3z/R3wcAACQhCzFGj5ZGjpQOHDjVbjMuGjSQuneXSpXysocAAAAAcFkQbAAeev/99y/L+1iNjo4dO7IcGQAAKdH+/dKIEb5Qw5af8gsJkZ56yhdoXHutlz0EAAAAgMsqVQYb48aNcwWUbXS6FWUeM2aMKleu/J/PsyLMVnD64Ycf1scffxzX/sorr7ht27ZtU2hoqCpWrOhGu1epUiWJPwkAAADSrL17fctN2bJTViDcL106qUkTqWtXqXhxL3uIVOKhd1nHHcDl99mT3q3hDgBI+VJdxcj33ntP7du3V+/evbVy5UoXbNSqVcsVRzyfLVu2qEOHDqpevfoZ20qUKKGxY8dqzZo1Cg8PV9GiRXXPPfdoz549SfhJAAAAkCbZMWbnzlLRotLAgadCjfTppeeek37/XZo8mVADAAAAQJqV6oKN4cOHq3nz5mratKmuu+46TZw4UZkyZdLUqVPP+Zzo6Gg1bNhQr776qqtzcLoGDRrorrvuctuuv/569x5WoX316tVJ/GkAAACQZuzaJXXo4As0hgyRIiJ87aGh0gsvSBs3Sq+/LhUr5nVPAQAAAMBTqWopqpMnT2rFihXqatPy/19wcLALJRYvXnzO5/Xp00d58+ZVs2bNtHDhwv98jzfeeEPZs2d3s0HO5sSJE+7mZyGIiYmJcbf47H5sbGzcLSn5Xz+p3wfJlxf7gH/fPtv+j8vP/28Of4u0i30A7APJ0I4dCho6VHrjDQUdOxbXHGuBxrPPKrZTJ6lQIV9jIv3dvN4P2P8AAAAAXIpUFWzs3bvXzb7Ily9fQLvdX79+/VmfY0tLTZkyRatWrTrva3/++ed64okndPToURUoUEDffPONcufOfdbHDhw40M3+OJ0tXXX8+PGAtsjISHdiZ0Wd7ZZU7MTVvhtD4ei0yat9wPZr28f37dun9LaEBjxlf4uDBw+6/cGCX6Q97ANgH0g+gnfsUOZx45TprbcUFG9QTGyGDDrasKEiWrZUTIECvsb/WFY1pe0Hhw8fvuzvCQAAACD1SFXBxsWcUDVq1EiTJk06Z0jhd8cdd7jww8ITe/zjjz+un376yc30OJ3NGLE6H/FnbBQqVEh58uRRtmzZAh5rQYf1I126dO6W1LiwjMu9D9h+bRdMcuXKpQwZMlzW98bZL2RZsGX/HnFBM21iHwD7QDKwbZuCBg+WpkxR0MmTcc2xGTNKzz+v2A4dlLFAAWVMxfsBxwQAAAAALkWqCjYsnAgJCdEuW584HrufP3/+Mx6/adMmVzT8oYceOmNavF2M3bBhg4r/f1HGzJkz65prrnG3m2++Wddee62b6RF/2Su/sLAwdzudnTSefuJo9+2k0n9LKjYaz//6zNhIm7zaB/z79tn2f3iDvwfYB8A+4JG//vIVA7fab5GRp9ozZZJefFFBVl8jXz4FpYH9gH0PAAAAwKVIVWcUoaGhqlixoubPnx8QVNj9W2655YzHlypVSmvWrHEzMfy32rVrx83OsFkW52KvG7+ORlr09NNPq06dOkqtbr/9drVt2zbRHgcAANKozZul5s2la67xFf/2hxqZM0udO0tbtkhWY+O05VQBAAAAAGlgxoaxJaCaNGmiSpUqqXLlyho5cqQiIiLUtGlTt71x48YqWLCgq4NhU+DLlCkT8PwcOXK4n/52e27//v1d4GG1NWwpqnHjxunvv//WY489pmRj61YrMnJmuy2xVbiwUisr5m6BVnxWR8I/AhEAAMAzmzZJ/ftLM2bYAcqp9qxZpdatJRsY8R/LoQIAAAAAzpTqrvzWr19fw4YNU69evVS+fHk38+Krr76KKyi+detW7dixI8GvZ0tbWeHxRx99VCVKlHDLVlkR5IULF+r6669Xsgk1SpaUKlY882bttv0ysJkLrVu3VqdOnZQzZ063/Ncrr7wS8JgDBw7o+eefd38Pf7Bkhdn9Zs+e7b5XW8qraNGieu211wKeb219+/Z1AZXVK3nuuec0ffp0F0h9+umnuu6669xz7e9sM2o6dOjggixbSqxKlSr6/vvvA17vxx9/dP3OlCmTrrjiCtWqVUv//vuvm42yYMECjRo1Km4pJVu27GJ07tzZ7Tv2HldffbV69uzpisb72Xdk++rMmTPd58uePbsrVB+/qKb93rBhQ/c5LGAbMWLEGTNFrI8ff/xxwHvb92Lfj58tnVayZMlz9sX069fP1Y7JmjWrnn32WXXp0sX1L77JkyerdOnS7m9oM5/Gjx9/Ud8NAACp0u+/S02a+I7Dpk07FWpkzy716uWbodGvH6EGAAAAAFykVDdjw7z00kvudjanX9g+XfyLwMYu3M6ZM0fJms3UOH787Nus3bafZ1mtxPTmm2+6WTNWWH3x4sUuILj11lt19913u+W77rvvPneR/q233nL1S3777TcXHpkVK1a4oux2od8CqkWLFunFF190Raftdfz8wVXv3r3dfQuZjh49qsGDB7sL7vZ4uzBv+4C9/qxZs3TllVfqo48+0r333uuWH7MaKRZ61axZU88884wLMKyuynfffedmfNj933//3QUvffr0ce9jxTUvhgUEtl9ZH+y9mzdv7tosAIpf78VCCQt5LFix72HQoEFutpCx79RCGAtvLBSyz79y5cozAoeE9GXatGku7DlbX95++233nhZU2N/NvjsLl4oVKxb3GvYYe/+xY8fqxhtv1M8//+xex0IXmy0FAECatX69L7B4911bt/RUu80IbtfON0vj/2cHAwAAAAAuXqoMNlKFSpWknTsT9tiTJ8+//d57rQBJwv7YVmR9+XJdrBtuuCEucLDwwC5+W40TCzb+97//aenSpVq3bp2bwWBs1oDf8OHDXdBgswiMPcaCiaFDhwYEG3feeadefvnluPsWbNisA7sYX65cOddmMzbsAr79tEDB2OwNm71j7QMGDNCQIUPckmXxZxvEn4VjS1zZzIazFZ6/ED169Ij73WZkWD8sMIgfbFjoY+GHhQymUaNG7nuzkMGCIAuM3nnnHff9GPsM/s91Ibp16+YCHJvdcba+jBkzRs2aNYtbus0CjHnz5unIkSNxr2F/Xws7HnnkEXffQg/7O73++usEGwCAtOm336S+faX33pNiY0+158xpoxNs1I1vtgYAAAAAIFEQbCRXFmr8/XfivNaePQpKnFdKULARny2btHv3bve7zZC46qqr4kKN01ng8fDDDwe02awBq5Nisyj8MzssjDidhRDx39tmI9hzTn8vW57KZnT4+3M56qS89957Gj16tJuVYQFBVFSUW0YrPgsZ/KHG6d/bn3/+6YIbqxnjZ8tV2ZJSF+r99993Qc65+rJhwwY3SyY+e99vv/02ruaMPdfCD5ul4WevY30CACBNWbPGF2h8+GFgoGHHGh06SC1b+uppAAAAAAASFcFGcnUhswRsxsaePefeniePYuMV2D5vyHGJsxPSp08fcN9mBthsBJMxY0YlBlvy6HT22vZefnbR3oIQW97KH4j4ZcmSJVH7cz62HJfVxnj11Vdd/Q67+O9f3imh31tC2XNi419UkQLqZ1hfbEaFLfVlS3Kdqy/n45+5MWnSJFezJL7Tv2cAAFKtVat8gcbpy5XaspUdO0ovvGAHHF71DgAAAABSPYKN5OpCloNaudJXKPxcvvpKuvFGN6reliFSvADgcrIZFdu3b3e1K842a8OKUVsdifjsvj32Qi+aW+0Hm7Fhsx6qV69+zv7Yck8WOpyNzQKx17gUViekSJEi6t69e1zbX3/9dUGvYct1WfCxbNkyFS5c2LUdPHjQfY81atSIe5zVANmxY0fc/Y0bN7raI2friz8EOr0vNgvE3seKs/vZfT+r72FLYNksEgtsAABIU1as8AUan3wS2J4vn2TLOj7/vI3A8Kp3AAAAAJBmEGykBrlzW5XzsxcQt3bbngzcdttt7kL8o48+6uppXHPNNVq/fr27yG4zCKxuxk033aS+ffu64uE2w8BqdMSvgZFQFobYhXe7QG8zEizo2LNnjwsyLNB44IEH1LVrV5UtW9YtvdSiRQsXZFjxcFueKnfu3G55KCuCvmXLFjfLI2fOnAoODj7r+9lr29JW8dlyUlZnxOp82MwI+2xffPGFK2J+IWyJKptp0bFjR9cHK4xudS6sL/FnqVjtEfu+brnlFhfIdO7cOWAmSPy+2PJSZ+tLq1at3BJTttxX1apV3TJaq1evDqiFYkFQ69at3YwP+7vZ8l7Lly93Rc+tyDkAAKmOhfx9+kiffx7YXqCA1LmzZMszZsrkVe8AAAAAIM05+1VapCw2in/DBt8owtNv1v7/o/yTg9mzZ7sL/E8++aSuu+46V7TaPyuiQoUKrgaEXXgvU6aMK1zdp0+fgMLhF8IKbFuwYYGJzUSoU6dOwKwHCz+sMPYvv/ziLvRbIPDJJ5/4ZrX8f7Fxmyli/bTZEBYKnIsV9rbwJP7NlmuqXbu22rVrp5deeknly5d3syb8xdEvhAVB1r8HH3xQd911l6s9YjNcMlhw9f8swClUqJCbodKgQQPXfyt+7md9sUDCwotz9cXCIAt87Ln299i8ebP7/uO/z7PPPqvJkye779eCIQusrPC5FREHACBVWbJEuv9+KzgVGGoULCiNGSNt2iS1aUOoAQAAAACXWVDs6YvyI9EdOnTIjW635YNOLxp9/Phxd/HYLgrHv3ic2OzP7F+KKv4of6RMVsS7YMGCLsywQt5JuQ/cfffdyp8/v2bOnHlRfb1c+zgSxmq32BJtNvPnXDOQkLqxD4B9IAFsaUyboTFvXmB7oUJS167SM89IYWFKybzeD853fOy1cePGaejQodq5c6fKlSunMWPGuEEw/8UG59jgnYcfflgff/xxivoeHnr3Ic/eG0Da9dmTn3ndheTtIf5tBuCRz7z79/lCjo9ZigpIAX7++We3bJedVNt/2DaTxdiJc2KymhwTJ050hc5ttsq7776r//3vf/rmm28S9X0AAEiWfvjBF2jMnx/YXqSI1K2b1KRJig80cH62DKctrWnHQ1WqVNHIkSPdcdGGDRtcCHQutnSpzXg9V203AAAAAImLYXpACjFs2DA3atCWorIZGwsXLnS1QBKTzeSYO3euq4VSsWJFffbZZ275MHtPAABSJZu8/N130h13WEGwwFDDllmcPFn6/XfpuecINdIAW/7T6o01bdrULUdqAYct7Tl16tRzPseWVbXlPK0OWfy6ZAAAAACSDjM2gBTAanassJopSSxjxoxuhgYAAGki0LAQw2ZoLFwYuK14calHDys+JaVP71UPcZmdPHnSHW9ZvTE/W6bLBngsXrz4nM+zmbQ2m8OWB7WBJ+dz4sQJd4s/1R4AAADAhSPYAAAAQNoKNKx2hgUaixYFbitRwhdoPPmklI7D5LRm7969bvZFvnz5Atrtvi0Jejbh4eGaMmWKVq1alaD3GDhwoJvZAQAAAODSsBQVAAAA0kagMXeudMst0r33BoYapUpJb78t/fab1KgRoQYS5PDhw2rUqJEmTZqU4OVBbTaI1Uvz37Zt25bk/QQAAABSI87akomYmBivuwAkCfZtAIDngcbnn/tmaCxfHrjt+uulnj2levWkkBCveohkwsKJkJAQ7dq1K6Dd7ufPn/+Mx2/atMkVDX/ooYfOOO5Jly6dKzhe3JY1iycsLMzdAAAAAFwagg2PhYaGurV7//nnH+XJk8fdtwLOiS02NlZRUVHuJCspXh/J3+XeB+z9bK3qPXv2uH3c9m0AAC5roPHJJ75A4+efA7eVLSv16iU98ogVUfCqh0hm7FilYsWKmj9/vurUqRMXVNj9l1566YzHlypVSmvWrAlo69Gjh5vJMWrUKBUqVOiy9R0AAABIawg2PGYXfIsVK6YdO3a4cCMpLzLbiZm9H8FG2uTVPpApUyYVLlzYvS8AAEnORsx/9JHUt6/0yy+B28qX9wUaDz9MoIGzat++vZo0aaJKlSqpcuXKGjlypCIiItS0aVO3vXHjxipYsKCrlZEhQwaVKVMm4Pk5cuRwP09vBwAAAJC4CDaSyegwu/Bro+mtYGFSsAva+/btU65cubjAnEZ5sQ/Ycg7MEgIAXLZA48MPfYHGr78GbqtY0Rdo2JJB/D8J51G/fn0327RXr17auXOnypcvr6+++iquoPjWrVs5lgYAAACSAYKNZMIu/KZPn97dkuqitr22jSzjZCxtYh8AAKRKNijk/felfv18xb/ju+kmqXdv6f77CTSQYLbs1NmWnjLff//9eZ87ffr0JOoVAAAAgPgINgAAAJDyREVJs2b5Ao0NGwK33XyzL9CoVYtAAwAAAABSIYINAAAApKxA4+23pf79pY0bA7fdeqsv0LjrLgINAAAAAEjFCDYAAACQ/EVGSjNn+gKNP/8M3Fajhi/QuOMOAg0AAAAASAMINgAAAJB8nTwpvfmmNGCAtGVL4LY77/QVBb/tNq96BwAAAADwAMEGAAAAkp8TJ6Rp06SBA6WtWwO33X23L9CoVs2r3gEAAAAAPESwAQAAgOTj+HFpyhRp0CBp+/bAbffe6ws0brnFq94BAAAAAJIBgg0AAAB479gxadIkafBg6Z9/Arc98IDUs6dUpYpXvQMAAAAAJCMEGwAAAPDO0aPS669LQ4ZIO3cGbqtd2xdoVKrkVe8AAAAAAMkQwQYAAAAuv4gIacIEaehQaffuwG116/oCjRtv9Kp3AAAAAIBkjGADAAAAl8/hw9L48dKwYdLevYHb6tWTevSQypXzqncAAAAAgBSAYAMAAABJ79AhaexY6bXXpP37T7UHBUmPP+4LNMqU8bKHAAAAAIAUgmADAAAASefAAWnMGGnECOnff0+1BwdLTzwhde8uXXedlz0EAAAAAKQwBBsAAABIfBZijBoljRwpHTwYGGg0bOgLNEqW9LKHAAAAAIAUimADAAAAiWffPl+YMXq0b/kpv5AQqVEjX6BxzTVe9hAAAAAAkMIRbAAAAODSWSHw4cN9y04dOXKqPV06qUkTqVs36eqrvewhAAAAACCVINgAAADAxdu921cQfNw4KSLiVHv69FLTplLXrlLRol72EAAAAACQyhBsAAAA4MLt3CkNHSpNmCAdO3aqPTRUatZM6tJFKlzYyx4CAAAAAFIpgg0AAAAk3D//SEOGSK+/Lh0/fqo9LExq3lzq3Fm66iovewgAAAAASOUINgAAAPDftm+XBg+WJk2STpw41Z4hg/T881KnTtKVV3rZQwAAAABAGkGwAQAAgHPbulUaNEiaMkU6efJUe8aM0gsvSB07Svnze9lDAAAAAEAaQ7ABAACAM23Z4gs0pk6VIiNPtWfKJLVsKXXoIOXN62UPAQAAAABpVLDXHQAAAEAy8uefvloZ117rq6PhDzWyZPEVBLfAw2psEGqkWHPWzVG518upyKQiuvH1G919AAAAAEhJmLEBAAAA6Y8/pAEDpBkzpOjoU+1Zs0qtW0vt2km5cnnZQySCd9e8qwZzGsTdX7N7jR59/1HNfny2Hin9iKd9AwAAAICEYsYGAABAWvb771LjxlLJktK0aadCjezZpV69pL/+kvr1I9RI4Y6cPKJhi4ap8UeNA9pjFasgBanPgj6e9Q0AAAAALhQzNgAAANKidet8MzRmzZJiYk6158jhm51hszTsd6RoB44f0NilYzViyQjtP7b/rI+xcGPDvg2XvW8AAAAAcLEINgAAANKStWuVvWdPBX36qRQbe6o9Z06pfXupVSspWzYve4hEsPfoXo1aMkqjl47WoROHzvtYm7FRMlfJy9Y3AAAAALhUBBsAAABpwerVUt++Cv7wQ2WM325LTHXoILVs6aungRRt55Gdem3Ra5qwfIIiIiPi2kOCQtSgbANVKlBJbb5u48IM/zJU9rP3bb097TcAAAAAXAiCDQAAgNRs1SqpTx/po48CmmPz5FFQx47SCy9IWbJ41j0kjm0Ht2nooqGatHKSjkcdj2tPH5xeTco1UZdqXVQ8Z3HXdlX2q/Tqgle1Ye8GlcxdUq/c9orqlq7rYe8BAAAA4MIQbAAAAKRGK1b4Ag1bciqe2Pz5dbhFC2V5+WUFEWikeH/++6cGhQ/S9FXTFRkTGdceFhKm5hWaq+OtHVU4e+GA5zxS+hHVKVlHu3fvVt68eRUcHOxBzwEAAADg4hFsAAAApCZLl/oCjS++CGwvUEDq0kWxzZrp6OHDypIpk1c9RCJYv3e9BiwcoHfWvKPo2Oi49kzpM+mFSi/o5VteVoGsBTztIwAAAAAkFYINAACA1GDxYl+g8dVXge0FC0pdu0rNmkkZMkgxMdLhw171Epdo9a7V6r+wvz5Y+4GrjeGXLSybWlVupbY3t1XuTLk97SMAAAAAJDWCDQAAgJQsPNwXaHzzTWB7oUK+QOOZZ6SwMK96h0Sy7O9l6rewnz7dELi0WM6MOdW2Slu1qtJKOTLk8Kx/AAAAAHA5EWwAAACkRAsW+AKNb78NbC9SROrWTXr6aSk01KveIZGEbw1Xvx/66etNXwe0582cVx1u6aAWlVooa1hWz/oHAAAAAF4g2AAAAEgpYmOl77+XXn3VF2zEV6yY1L271LixlD69Vz1EIoiNjdW3m79V3x/6asFfgX/nglkLqtOtnfRshWddPQ0AAAAASIsINgAAAFJCoDF/vi/QsKWn4rvmGl+g0bAhgUYqCDTmbpzrlpxasn1JwLaiOYqqa7WualKuicLSsbQYAAAAgLSNYAMAACA5Bxrz5vkCDSsOHl/JklKPHtITT0jpOKRLyWJiY/Tx+o/dklM/7/w5YFuJXCXUrVo3NSjbQOlDCK4AAAAAwHAWDAAAkBwDjS+/9NXQ+OmnwG2lS0s9e0qPPy6FhHjVQySCqJgovb/2ffVf2F+/7fktYFuZvGXUo3oP1buunkKC+TsDAAAAQHzBSoXGjRunokWLKkOGDKpSpYqWLl2aoOfNmjVLQUFBqlOnTlxbZGSkOnfurLJlyypz5sy68sor1bhxY/3zzz9J+AkAAECaDTQ+/VS66SbpgQcCQ43rr5fee09as0Z68klCjRQsMjpSU3+eqtLjSqvhnIYBoUbFAhX1Uf2P9EuLX1S/TH1CDQAAAABIC8HGe++9p/bt26t3795auXKlypUrp1q1amn37t3nfd6WLVvUoUMHVa9ePaD96NGj7nV69uzpfs6ZM0cbNmxQ7dq1k/iTAACANCMmRvroI6lCBenhh6UVK05tu+EG6cMPpdWrmaWRwh2POq4JyybomjHXqNmnzfTH/j/itlUtVFVfNvxSy5ovU51SdRQclOoO0wEAAAAg0aS6paiGDx+u5s2bq2nTpu7+xIkT9cUXX2jq1Knq0qXLWZ8THR2thg0b6tVXX9XChQt14MCBuG3Zs2fXN998E/D4sWPHqnLlytq6dasKFy6cxJ8IAACk6kBjzhypb19fcBHfjTdKvXpJNpgimIvcKVnEyQi9seINDV00VDuO7AjYdmexO92SU7cXvd3NHAYAAAAApLFg4+TJk1qxYoW6du0a1xYcHKy77rpLi08vuBlPnz59lDdvXjVr1swFG//l4MGD7sQzR44cidZ3AACQhkRH+2ZhWKCxdm3gtooVpd69pQcflLjQnaIdOnFI45eN1/DFw7Xn6J6Abfdfe7+6V+/uZmoAAAAAANJwsLF37143+yJfvnwB7XZ//fr1Z31OeHi4pkyZolWrViXoPY4fP+5qbjz55JPKli3bWR9z4sQJd/M7dOiQ+xkTE+NuXrD3jY2N9ez94T32ARj2A7APJINA4733FDRggILWrQvYFFu5smKtKPh99/kCDau3YbdExj6Q9PYf268xS8do9NLROnD81ExgU6dkHRdoVChQwd1Pq8eG7H8AAAAALkWqCjYu1OHDh9WoUSNNmjRJuXPn/s/HWyHxxx9/3J0ETpgw4ZyPGzhwoFvW6nR79uxxwYhXJ48208T6brNYkPawD8CwH4B9wCNRUcrw0UfKMmqU0m3aFLDpZKVKOtK+vU7efrsv0NgTOLI/sbEPJJ29x/bq9dWva/ra6ToSeSSu3eplPFz8YbW+sbVK5Szl2v6r/ltS83o/sONwAAAAALhYqSrYsHAiJCREu3btCmi3+/nz5z/j8Zs2bXJFwx966KEzRo+lS5fOFQkvXrx4QKjx119/6dtvvz3nbA1jS2FZAfP4MzYKFSqkPHnynPd5Sck+ly2fZX3gIkbaxD4Aw34A9oHLLCpKeustBQ0cqKA/ThWKNrHVqrkZGulq1lSOy7jkFPtA4vvn8D8atniYq6NxLOpYXHtIUIieuuEpdbm1i0rkKqHkxOv9IEOGDJf9PQEAAACkHqkq2AgNDVXFihU1f/581alTJ+6kze6/9NJLZzy+VKlSWrNmTUBbjx493AiyUaNGuTAifqixceNGfffdd8qVK9d5+xEWFuZup7OTRi8vINjJq9d9gLfYB2DYD8A+cBlERkozZkgDBkh//hm47bbbXA2NoNu9KxbNPpA4/jrwlwb/OFhTfp6ik9En49pDQ0L1TPln1LlaZxXNUVTJlZf7AfseAAAAgEuRqoINYzMlmjRpokqVKqly5coaOXKkIiIi1LRpU7e9cePGKliwoFsuykaKlSlTJuD5/oLg/nYLNerVq6eVK1fq888/dzU8du7c6bblzJnThSkAAADOyZPS9Om2LqW0ZUvgtjvvlHr18gUbSNE27tuogeEDNXP1TEXFRMW1Z0yXUc9XfF4dqnZQwWwFPe0jAAAAAKRmqS7YqF+/vqtl0atXLxdAlC9fXl999VVcQfGtW7de0Aixv//+W59++qn73V4rPpu9cbuthw0AANK2EyekqVN9gca2bYHb7r7bF2hUq+ZV75BI1u5eqwHhAzTr11mKiT1V/DpLaBa1vKml2t3cTvmy+I45AQAAAABJJ9UFG8aWnTrb0lPm+++/P+9zp9soy3iKFi3qiioCAACc4fhxafJkadAgGw0RuO3ee32Bxi23eNU7JJKVO1aq/8L+mrNuTkB7jgw51KZKG7Wu0lo5M+b0rH8AAAAAkNakymADAAAgSR07Jr3xhjR4sLRjR+C2Bx7wBRqVK3vVOySSxdsWu0Dji41fBLTnzpRb7W9urxdvelHZM2T3rH8AAAAAkFYRbAAAACTU0aPSxInSkCHSrl2B22rX9gUaFSt61TskApupu+CvBer3Qz/N3zw/YFuBLAXUsWpHPVfxOWUOzexZHwEAAAAgrSPYAAAA+C9HjkgTJkjDhkm7dwduq1tX6tlTuvFGr3qHRAo05m2ap34L+yl8a3jAtsLZC6vzrZ31zI3PKEO6DJ71EQAAAADgQ7ABAABwLocPS+PGSa+9Ju3de6o9KEiqV0/q0UO64QYve4hLZEXAP9vwmQs0lv+zPGBb8SuKq1v1bnrqhqcUGhLqWR8BAAAAAIEINgAAAE538KA0dqw0fLi0f39goFG/vi/QuP56L3uISxQdE63Z62a7Ghqrd60O2FY6d2l1r95d9cvUV7pgDpcBAAAAILnhTA0AAMDvwAFp9GhpxAjf737BwdKTT0rdu0ulS3vZQ1yiqJgovbPmHQ1YOEAb9m0I2FY+f3n1qN5DdUvXVXBQsGd9BAAAAACcH8EGAACAzcoYNcp3s9ka8QONp56SunWTSpb0soe4RCeiTmjGLzM0MHygNh/YHLCtSsEq6lGjhx649gEF2awcAAAAAECyRrABAADSrn37fLMzbJaG1dPwCwmRGjf2BRrXXONlD3GJjkUe0+SVkzVk0RBtP7Q9YFuNIjXUs0ZP1SxWk0ADAAAAAFIQgg0AAJD27Nnjq59hdTSOHDnVni6d9PTTUteu0tVXe9lDXKIjJ49o4vKJGrZomHZF7ArYdk/xe1wNDQs2AAAAAAApD8EGAABIO3bvloYNk8aPlyIiTrWnTy8984zUpYtUtKiXPcQlOnD8gMYuHasRS0Zo/7F4hd8l1S5Z2wUalQtW9qx/AAAAAIBLR7ABAABSv507paFDpQkTpGPHTrWHhkrNmvkCjcKFvewhLtHeo3s1askojV46WodOHIprD1KQ6l1XT92qd3PFwQEAAAAAKR/BBgAASL3++UcaMkR6/XXp+PFT7WFh0nPPSZ06SVdd5WUPcYl2Htmp1xa9pgnLJygi8tQsnJCgEDUo20Bdq3VV6TylPe0jAAAAACBxEWwAAIDUZ/t2afBgadIk6cSJU+0ZMkgtWkgdO0pXXullD3GJth3cpqGLhmrSykk6HnUqtEofnF5NyjVRl2pdVDxncU/7CAAAAABIGgQbAAAg9di6VRo4UJo6VTp58lR7xozSiy9KHTpI+fN72UNcoj///VODwgdp+qrpioyJjGsPCwlT8wrN1fHWjiqcnWXFAAAAACA1I9gAAAAp35YtvkBj2jQp8tTFbmXOLLVsKb38spQ3r5c9xCVav3e9BiwcoHfWvKPo2Oi49kzpM+mFSi/o5VteVoGsBTztIwAAAADg8iDYAAAAKdeff0oDBkhvvilFRZ1qz5JFatVKat9eyp3byx7iEq3etVr9F/bXB2s/UKxi49qzhWVTq8qt1Pbmtsqdib8xAAAAAKQlBBsAACDl2bjRF2jMnClFnxq9r2zZpNatpbZtpVy5vOwhLtGyv5ep38J++nTDpwHtOTPmVNsqbdWqSivlyJDDs/4BAAAAALxDsAEAAFKODRuk/v2lt9+WYmJOtWfP7gsz2rSRrrjCyx7iEoVvDVe/H/rp601fB7TnzZxXHW7poBaVWihrWFbP+gcAAAAA8B7BBgAASP7WrZP69ZNmzQoMNCzEaNfOt+xUDkbvp1SxsbH6dvO36vtDXy34a0HAtoJZC6rTrZ30bIVnXT0NAAAAAAAINgAAQPL166++QOP99+3q96n2nDl9BcFfesm3/BRSbKAxd+Nct+TUku1LArYVzVFUXat1VZNyTRSWLsyzPgIAAAAAkh+CDQAAkPysXi316SPNnh3YboXAO3SQXnxRyspyRClVTGyMPl7/sVty6uedPwdsK5GrhLpV66YGZRsofUh6z/oIAAAAAEi+CDYAAEDy8fPPvkDj448D2/PmlTp2lF54Qcqc2ave4RJFxUTp/bXvq//C/vptz28B28rkLaMe1Xuo3nX1FBIc4lkfAQAAAADJH8EGAADw3vLlvkDjs88C2/Pnlzp1kp5/XspEfYWUKjI6UjNXz9TA8IH6Y/8fAdsqFqioHjV6qHbJ2goOCvasjwAAAACAlINgAwAAeGfpUunVV6W5cwPbr7xS6txZat5cypjRq97hEh2POq5pP0/ToB8HaevBrQHbqhaqqp41eqpW8VoKCgryrI8AAAAAgJSHYAMAAFx+ixf7Ao2vvw5sv+oqqUsXqVkzKUMGr3qHSxRxMkJvrHhDQxcN1Y4jOwK23VnsTrfk1O1FbyfQAAAAAABcFIINAABw+YSH+wKN//0vsL1wYalrV6lpUykszKve4RIdOnFI45eN1/DFw7Xn6J6Abfdfe7+6V+/uZmoAAAAAAHApCDYAAEDSW7DAF2h8911ge9GiUrduUpMmUmioV73DJdp/bL9G/zRao34apQPHDwRsq1uqrquhUaFABc/6BwAAAABIXQg2AABA0oiN9QUZFmj88EPgtquvlrp3lxo1ktKn96qHuES7I3ZrxOIRGrdsnA6fPBzXbkXA619fX92qd1OZvGU87SMAAAAAIPUh2AAAAIkfaNhSUxZo/Phj4LZrrpF69JAaNpTScRiSUv196G8NWzRMr694XceijsW1hwSFqFG5RuparatK5CrhaR8BAAAAAKkXVxQAAEDiBRpWDNwCjSVLAreVLOkLNJ54gkAjBdtyYIuG/DhEU36eopPRJ+PaQ0NC9Uz5Z9S5WmcVzVHU0z4CAAAAAFI/riwAAIBLDzTmzpX69JGWLg3cVrq01LOn9PjjUkiIVz3EJdq4b6MGhg/UzNUzFRUTFdeeMV1GPV/xeXWo2kEFsxX0tI8AAAAAgLQj2OsOAACAFBxofPqpdNNN0oMPBoYaZcpI770n/fqr9OSThBop1Nrda9VwTkOVGldK01ZNiws1soRmUedbO2tzm80ace8IQg2kKuPGjVPRokWVIUMGValSRUtPD2zjmTNnjipVqqQcOXIoc+bMKl++vGbOnHlZ+wsAAACkRczYAAAAFyYmRvrkE98MjVWrArfdcIPUq5dUt64UzPiJlGrljpXqv7C/5qybE9CeI0MOtanSRq2rtFbOjDk96x+QVN577z21b99eEydOdKHGyJEjVatWLW3YsEF58+Y94/E5c+ZU9+7dVapUKYWGhurzzz9X06ZN3WPteQAAAACSBsEGAABIeKAxZ47Ut6+0enXgthtv9AUatWsTaKRgi7ctdoHGFxu/CGjPnSm32t/cXi/e9KKyZ8juWf+ApDZ8+HA1b97chRPGAo4vvvhCU6dOVZcuXc54/O233x5wv02bNnrzzTcVHh5OsAEAAAAkIYINAABwftHR0ocf+gKNtWsDt1Wq5As0bCmqoCCveohLEBsbqwV/LVC/H/pp/ub5AdsKZCmgjlU76rmKzylzaGbP+ghcDidPntSKFSvUtWvXuLbg4GDdddddWrx4cYL+W/r222/d7I7BgwcncW8BAACAtI1gAwAAnDvQmDVL6tdPWr8+cFuVKlLv3tK99xJopFB2EfbrP75Wv4X9FL41PGBb4eyFXQ2NZ258RhnSZfCsj8DltHfvXkVHRytfvnwB7XZ//en/BsZz8OBBFSxYUCdOnFBISIjGjx+vu++++6yPtcfYze/QoUOJ+AkAAACAtINgAwAABIqKkt55R+rfX/r998BtVav6Ag27aEegkSLFxMboqy1fadyn47R8x/KAbcWvKK5u1bvpqRueUmhIqGd9BFKSrFmzatWqVTpy5Ijmz5/vanRcffXVZyxTZQYOHKhXX33Vk34CAAAAqQnBBgAA8ImMlN56yxdobNoUuK16dV+gceedBBopVHRMtGavm63+P/TX6t2BNVJK5y6t7tW7q36Z+koXzOEh0qbcuXO7GRe7du0KaLf7+fPnP+fzbLmqa665xv1evnx5rVu3zgUYZws2bJkrCz7iz9goVKhQon4OAAAAIC3gzBUAgLTu5ElpxgxpwABp8+bAbXZhzmpo2E8CjRQpKiZK76x5RwMWDtCGfRsCtpXPX149qvdQ3dJ1FRxE0XekbaGhoapYsaKbdVGnTh3XFhMT4+6/9NJLCX4de0785abiCwsLczcAAAAAl4ZgAwCAtBxoTJtma6NIf/0VuK1mTV+gUaOGV73DJToRdUIzfpmhgeEDtflAYGBVIW8F9b6jtx4q+ZCCCKyAODabokmTJqpUqZIqV66skSNHKiIiQk2bNnXbGzdu7Opp2IwMYz/tscWLF3dhxty5czVz5kxNmDDB408CAAAApG4EGwAApDU2ktguug0eLG3bFrjtnnt8gcatt3rVO1yiY5HHNHnlZA1ZNETbD20P2FajSA11r9ZdZTOXdQWRCTWAQPXr19eePXvUq1cv7dy50y0t9dVXX8UVFN+6datbesrPQo8XX3xR27dvV8aMGVWqVCm99dZb7nUAAAAAJB2CDQAA0orjx6VJk5Rn4EAF79gRuO2++6SePaVbbvGqd7hER04e0cTlEzVs0TDtigisEXBP8XtcDQ0LNmyZnN27d3vWTyC5s2WnzrX01Pfffx9wv1+/fu4GAAAA4PIi2AAAILU7elR64w1pyJAzA40HH/TN0LjpJq96h0t04PgBjV06ViOWjND+Y/sDttUuWdsFGpULVvasfwAAAAAApIpg49NPP03wY2vXrp2kfQEAINWKiJAmTpSGDpV2BY7gj61dW0G9e0sVKnjWPVyavUf3atSSURq9dLQOnTgU1x6kINW7rp66Ve/mioMDAAAAAJDaeBJs1KlTJ+C+re8cGxsbcN8vOjr6svYNAIAU78gRafx4adgwac+egE2xdetq34svKueddyoo3jrxSDl2Htmp1xa9pgnLJygiMiKuPSQoRA3KNlDXal1VOk9pT/sIAAAAAEBS8uSKhq3t7L/NmzfPFeX78ssvdeDAAXebO3euKlSo4Ar1AQCABDp8WBo4UCpaVOrc+VSoYQMGHntMWr1asR9+qKgyZbzuKS7CtoPb1PrL1io2qpiGLR4WF2qkD06vZ298Vhte2qAZdWcQagAAAAAAUj3Pa2y0bdtWEydOVLVq1eLaatWqpUyZMum5557TunXrPO0fAADJ3sGD0pgx0ogR0v54NRYs0KhfX+rRQ7r+el9bTIxn3cTF+fPfPzUofJCmr5quyJjIuPawkDA1r9BcHW/tqMLZC3vaRwAAAAAA0lSwsWnTJuXIkeOM9uzZs2vLli2e9AkAgBThwAFp1Chp5Ejf7362xNSTT/oCjVKlvOwhLsH6ves1YOEAvbPmHUXHnlqaM1P6THqh0gt6+ZaXVSBrAU/7CAAAAABAmgw2brrpJrVv314zZ85Uvnz5XNuuXbvUsWNHVa5c2evuAQCQ/NisDAszLNQ4dKpotEJCpIYNpe7dpRIlvOwhLsHqXavVf2F/fbD2A8XqVA2ybGHZ1KpyK7W9ua1yZ8rtaR8BAAAAAEjTwcaUKVP0yCOPqHDhwipUqJBr27Ztm6699lp9/PHHXncPAIDkY+9e33JTtuyU1dOIH2g0bix16yZdc42XPcQlWPb3MvVb2E+fbvg0oD1nxpxqW6WtWlVppRwZzpzlCgAAAABAWuN5sGEBxurVq/XNN99o/fr1rq106dK66667FGRrgwMAkNZZEfDXXpPGjpUifAWjnXTppKeflrp2la6+2sse4hKEbw1Xvx/66etNXwe0582cVx1u6aAWlVooa1hWz/oHAAAAAEBy42mwERkZqYwZM2rVqlW655573A0AAPy/XbukYcOk8eOlo0dPtadPLzVrJnXpIhUp4mUPcZFiY2P17eZv1feHvlrw14KAbQWzFlSnWzvp2QrPunoaAAAAAAAgGQUb6dOnd0tQRUefKogJAECat2OHNHSoNHGidOzYqfbQUOnZZ32Bxv8v34iUF2jM3TjXLTm1ZPuSgG1FcxRV12pd1aRcE4WlC/OsjwAAAAAAJHeeL0XVvXt3devWzRUPz5kzp9fdAQDAO3//LQ0ZIr3xhnT8+Kn2sDDpueekzp2lggW97CEuUkxsjD5e/7FbcurnnT8HbCuRq4S6VeumBmUbKH1Ies/6CAAAAABASuF5sDF27Fj98ccfuvLKK1WkSBFlzpw5YPvKlSs96xsAAJfFtm3S4MHS5MnSiROn2jNkkFq0kDp1kgoU8LKHuEhRMVF6f+376r+wv37b81vAtjJ5y6hH9R6qd109hQSHeNZHAAAAAABSGs+DjTp16iT6a44bN05Dhw7Vzp07Va5cOY0ZM0aVK1f+z+fNmjVLTz75pB5++GF9/PHHce1z5szRxIkTtWLFCu3fv18///yzypcvn+j9BgCkMVu3SgMHSlOnSidPnmrPlEl64QWpQwcpf34ve4iLFBkdqZmrZ2pg+ED9sf+PgG0VC1RUjxo9VLtkbQUHBXvWRwAAAAAAUirPg43evXsn6uu99957at++vQsiqlSpopEjR6pWrVrasGGD8ubNe87nbdmyRR06dFD16tXP2BYREaFq1arp8ccfV/PmzRO1vwCANGjLFmnAAGn6dCky8lS7zVps2VJ6+WXpPP/PQvJ1POq4pv08TYN+HKStB7cGbKtaqKp61uipWsVrKSgoyLM+AgAAAACQ0nkebCS24cOHu/ChadOm7r4FHF988YWmTp2qLlZs9SyseHnDhg316quvauHChTpw4EDA9kaNGsWFHwAAXLRNm3yBxowZUlTUqfYsWaRWraT27aXcub3sIS5SxMkIvbHiDQ1dNFQ7juwI2HZnsTvdklO3F72dQAMAAAAAgNQQbFioMGLECL3//vvaunWrTsZfikNySz8llD3Xlovq2rVrXFtwcLDuuusuLV68+JzP69Onj5vN0axZMxdsXKoTJ064m9+hQ4fcz5iYGHfzgr1vbGysZ+8P77EPwLAfeGTjRgVZoPH22wqKjo5rjs2WTWrdWrFt2kg5c/oak/hvwz6QuA6dOKQJyydoxJIR2nN0T8C2+665zxUFt5kaxr53u3mNfQDJYT9g/wMAAACQooMNmyUxefJkvfzyy+rRo4e6d+/uZkZYjYtevXpd0Gvt3bvXBSX58uULaLf769evP+tzwsPDNWXKFK1atUqJZeDAge5znW7Pnj06fvy4vDp5PHjwoDuBtbAHaQ/7AAz7weUVsnGjsowapQwffaSgeBfxYrJnV0Tz5jrarJlic+Twzd7Yvfuy9Il9IHH8e/xfTfl1iiavmayDJw8GbLuv6H1qW6Gtbshzg7u/+zL9bROKfQDJYT84fPjwRT/XP2goIbJZgAwAAAAg1fE82Hj77bc1adIkPfDAA3rllVdc8e7ixYvrhhtu0JIlS9S6deskPaGyZabs/XMn4tIfNmPE6nzEP/kqVKiQ8uTJ49nJlZ282vIX1gcuYqRN7AMw7AeXyW+/Kah/fyv8pKB4I/Rjr7hCse3aSS+9pMzZsyuzB11jH7g0uyN2a+SSkRq/fLwOnzx1YdaKgD9+3ePqWq2ryuQto+SMfQDJYT/IkCHDRT83R44cCV7WzQY9AQAAAEh9PA82du7cqbJly7rfs2TJ4kaOmQcffFA9e/a8oNeycCIkJES7du0KaLf7+fPnP+PxmzZtcrNDHnrooTOmxadLl84VHLeQ5UKFhYW52+nspNHLCwh2Auh1H+At9gEY9oMktGaN1K+f9MEHtu7QqfZcuVxB8KCWLRWUDEYPsw9cuL8P/a1hi4bp9RWv61jUsbj2kKAQNSrXyAUaJXKVUErBPgCv94NLec/vvvsu7nc7lrc6ek8//bRuueUW12ZL0L755ptuFjUAAACA1MnzYOOqq67Sjh07VLhwYRcizJs3TxUqVNCyZcvOGg6cT2hoqCpWrKj58+erTp06cUGF3X/ppZfOeHypUqW0xi5CxWPLYdlMjlGjRrlZFgAA/KdffpH69pVmzw5st9mAHTtKL7wgZc3qVe9wCbYc2KIhPw7RlJ+n6GT0qTpgoSGheqb8M+pcrbOK5ijqaR+BtOa2224LqJU3fPhwN+vbr3bt2m7g1BtvvKEmTZp41EsAAAAAqTrYqFu3rgseqlSpolatWumpp55yNS+skHg7W67jAtkSUHYCU6lSJVWuXFkjR45URESEmjZt6rY3btxYBQsWdCO4bAp8mTJlzpjabuK3WwFz688///zj7ttMDmOzQM42EwQAkEasXOkLND7+OLA9b16pUyepRQspsxcLTuFSbdy3UQPDB2rm6pmKiomKa8+YLqOer/i8OlTtoILZCnraRwC+2RkTJ048o93OBZ599llP+gQAAAAgDQQbgwYNivu9fv36KlKkiBYtWqRrr702YImohLLXsCLdVnjclrkqX768vvrqq7iC4hZQXOjU908//TQuGDFPPPGE+9m7d29XFwQAkMYsW+YLND77LLDdwu7OnaXnnpMyZfKqd7gEa3ev1YDwAZr16yzFxJ4q+J4lNIta3tRS7W5up3xZfMcUALxnM6ytXt6QIUMC2idPnszsawAAACAV8zzYON3NN9/sbpfClp0629JT5vvvvz/vc6dPn35Gm63ZazcAQBr300/Sq69KX34Z2H7llVKXLpKNDs6Y0ave4RKs3LFS/Rf215x1cwLac2TIoTZV2qh1ldbKmTGnZ/0DcHYjRozQo48+qi+//NLNADdLly7Vxo0bNfv05QEBAAAApBqeBxtWW+P22293a+Xaz4sp1g0AQJJatMgXaMybF9h+1VVS167SM89IGTJ41TtcgsXbFrtA44uNXwS0586UW+1vbq8Xb3pR2TNk96x/AM7v/vvvdyHGhAkTtG7dOtdms75btGjBjA0AAAAgFfM82BgwYIB++OEHDR48WM2bN3f1Lyzk8AcdtiQVAACeWLjQF2jMnx/YXriw1K2bTemTwsK86h0uUmxsrBb8tUD9fuin+ZsD/7YFshRQx6od9VzF55Q5lPooQHIWGRmpe++919XY6N+/v9fdAQAAAJCWgg0rFm43s2PHDi1YsECff/65XnzxRcXExCg6OtrrLgIA0hpbttACjdOXLyxaVOreXWrcWAoN9ap3uIRAY96meeq3sJ/Ct4YHbCucvbA639pZz9z4jDKkY/YNkBKkT59eq1ev9robAAAAANJisGGOHj2q8PBwV//iu+++088//6wyZcq4GRsAAFwWsbHSt99KffpIP/wQuM2WSbRAw4L49Om96iEukhUB/2zDZy7QWP7P8oBtxa8orm7Vu+mpG55SaAhhFZDS2ACpKVOmaNCgQV53BQAAAEBaCjaqVq3qgozSpUu7IKNLly6qUaOGrrjiCq+7BgBIK4HGN9/4Ao0ffwzcZssh9ughNWggpfP8f5m4QNEx0Zq9brarobF6V+Co7tK5S6t79e6qX6a+0gXztwVSqqioKE2dOlX/+9//VLFiRWXOHLiE3PDhwz3rGwAAAICk4/mZ/Pr1690JSKlSpdzNAg5CDQDAZQk0vvrKF2gsWRK4rWRJqWdPqX59Ao0UKComSu+seUcDFg7Qhn0bAraVz19ePar3UN3SdRUcFOxZHwEkjl9//VUVKlRwv//+++8B24KCgjzqFQAAAICk5vnVmn379mnNmjVuGaqvv/5a3bt3V2hoqCsefscdd7iC4gAAJGqg8cUXvkBj2bLAbddd5ws0HntMCgnxqoe4SCeiTmjGLzM0MHygNh/YHLCtSsEq6lGjhx649gEudgKpiC1jCwAAACDt8TzYsIsLN9xwg7u1atVKK1as0NixY/X222/rvffeI9gAACReoPHpp75AY+XKwG1lyki9ekmPPioFM4o/pTkWeUyTV07WkEVDtP3Q9oBtNYrUUM8aPVWzWE0CDQAAAAAAUgnPg42VK1e62Rp2swLihw8fVtmyZV3IYbM2AAC4JDEx0scf+wKNX34J3FaunC/QqFOHQCMFOnLyiCYun6hhi4ZpV8SugG33FL/H1dCwYANA6rZ8+XK9//772rp1q06ePBmwbc6cOZ71CwAAAEAqDjYqV66sG2+80YUYNjvDCodnz57d624BAFJDoDF7ttS3r7RmTeA2W4/dAo3atW3qoFc9xEU6cPyAxi4dqxFLRmj/sf0B22qXrO0CjcoFK3vWPwCXz6xZs9S4cWPVqlVL8+bN0z333ONqbezatUt169b1unsAAAAAUmuwsX//fmXLls3rbgAAUovoaOmDD3yBxm+/BW6rVEnq3Vt64AECjRRo79G9GrVklEYvHa1DJw7FtQcpSPWuq6du1bu54uAA0o4BAwZoxIgRatmypbJmzapRo0apWLFiev7551WgQAGvuwcAAAAgtQYbFmocOHBAH374oTZt2qSOHTsqZ86cbomqfPnyqWDBgl53EQCQEkRFSe+9J/XrJ61fH7itShVfoHHvvQQaKdDOIzv12qLXNGH5BEVERsS1hwSFqEHZBuparatK5yntaR8BeMPOHx6wsFpSaGioIiIiXD2ddu3a6c4779Srr77qdRcBAAAApMZgY/Xq1apZs6Zy5MihLVu2uOWoLNiw9XBtndwZM2Z43UUAQHIPNN55xxdobNwYuK1qVV+gcffdBBop0LaD2zR00VBNWjlJx6OOx7WnD06vJuWaqEu1Liqes7infQTgrSuuuMLV6DM2IOrXX3919fps4NTRo0e97h4AAACA1BpstG/fXk2bNtWQIUPc9HG/+++/Xw0aNPC0bwCAZCwyUnrrLal/fxuyG7itenVfoHHnnQQaKdCf//6pQeGDNH3VdEXGRMa1h4WEqXmF5up4a0cVzl7Y0z4CSB6sPt8333zjwozHHntMbdq00bfffuvabPAUAAAAgNTJ82Bj2bJlev31189otxFXO3fu9KRPAIBk7ORJ6c03bWF1acuWwG233+4LNOwnUpz1e9drwMIBemfNO4qOjY5rz5Q+k16o9IJevuVlFcjKmvkAThk7dqyOH/fN6OrevbvSp0+vRYsW6dFHH1WPHj287h4AAACA1BpshIWF6dChUwVA/X7//XflyZPHkz4BAJKhEyekadOkgQOlrVsDt9mo3F69bOiuV73DJVi9a7X6L+yvD9Z+oFjFxrVnC8umVpVbqe3NbZU7U25P+wggebIlbP2Cg4PVpUsXT/sDAAAAII0EG7Vr11afPn30/vvvu/tW7M9qa3Tu3NmNtAIApHE2EnfKFGnQIGn79sBttWpJPXtKt97qVe9wCZb9vUz9FvbTpxs+DWjPmTGn2lZpq1ZVWilHhhye9Q9A8te4cWPdcccdbkmq4sWpuQMAAACkFcFed+C1117TkSNHlDdvXh07dky33XabrrnmGmXJkkX9bd10AEDadOyYNGaMZBeqXnopMNS4/35p8WLpq68INVKg8K3huvete1V5cuWAUCNv5rwactcQbWmzRT1v60moAeA/hYaGauDAgbr22mtVqFAhPfXUU5o8ebI2btzoddcAAAAApOYZG9mzZ3fF/cLDw7V69WoXclSoUEF33XWX110DAHjh6FHpjTekwYOl02stPfSQb4bGTTd51TtcpNjYWM3fPF/9fuinBX8tCNhWMGtBdbq1k56t8KyrpwEACWUhhvn777/1ww8/aMGCBW7g1PPPP68CBQpo++kz/QAAAACkCp4HG37VqlVzN7+VK1eqV69e+vzzzz3tFwDgMomIkCZOlIYOlXbtCtxWp44v0KhQwave4RICjbkb57olp5ZsXxKwrWiOouparaualGuisHRhnvURQMp3xRVXKFeuXO5njhw5lC5dOur1AQAAAKmYp8HG119/7WZr2BTyZ599VldffbXWr1/viv599tlnqmVrpwMAUrcjR6Tx46Vhw6Q9ewK3Wa2lHj2k8uW96h0uUkxsjD5a95ELNFbtXBWwrUSuEupWrZsalG2g9CHpPesjgJSvW7du+v777/Xzzz+rdOnSbllbO5ewmhsWcgAAAABInTwLNqZMmaLmzZsrZ86c+vfff9008uHDh6tVq1aqX7++fv31V3dyAgBIpQ4dksaNs2JL0r59p9qDgqTHHvMFGmXLetlDXISomCi9v/Z99V/YX7/t+S1gW5m8ZdSjeg/Vu66eQoJDPOsjgNRj0KBBbmZG79699cgjj6hEiRJedwkAAABAag42Ro0apcGDB6tjx46aPXu2HnvsMY0fP15r1qzRVVdd5VW3AABJ7eBBafRoacQI6d9/AwONJ56QuneXrr/eyx7iIkRGR2rm6pkaGD5Qf+z/I2BbxQIV1aNGD9UuWVvBQcGe9RFA6mMzNayuhs3asNoaNhPcZm3cfvvt7kbQAQAAAKROngUbmzZtcmGGsdFVtg7u0KFDCTUAILWyEGPUKGnkSF+44RccLDVo4As0SpXysoe4CMejjmvaz9M06MdB2npwa8C2qoWqqmeNnqpVvJaCLLgCgERWrlw5d2vdurW7/8svv2jEiBFq2bKlYmJiFB0d7XUXAQAAAKSmYOPYsWPKlCmT+90udoSFhalAgQJedQcAkFT27/fNzrBZGrb8lF9IiPTUU7ZAusSI2hQn4mSE3ljxhoYuGqodR3YEbLuz2J1uyanbi95OoAEgScXGxrpZGzZjw27h4eE6dOiQbrjhBjdzAwAAAEDq5GnxcKurkSVLFvd7VFSUpk+frty5cwc8xj/6CgCQwuzdKw0fLo0Z4ysQ7pcundS4sS/QKF7cyx7iIhw6cUjjl43X8MXDtedoYLH3+6+9X92rd3czNQDgcrB6fUeOHHGzNizIsBp+1atXV44cObzuGgAAAIDUGGwULlxYkyZNirufP39+zZw5M+AxNsqTYAMAUpg9e6Rhw3yFwSMiAgONpk2lrl2lYsW87CEuwv5j+zX6p9Ea9dMoHTh+IGBb3VJ1XQ2NCgUqeNY/AGnTW2+95YKMbNmyed0VAAAAAGkh2NiyZYtXbw0ASAq7dklDh0oTJkhHj55qT59eatZM6tJFKlLEyx7iIuyO2K0Ri0do3LJxOnzycFy7FQGvf319daveTWXylvG0jwDSrgceeMD9/OOPP1wNvxo1aihjxoxuiSqWwgMAAABSL0+XogIApAI7dkhDhkivv24FlE61h4ZKzZtLnTtLhQp52UNchL8P/a1hi4bp9RWv61jUqb9rSFCIGpVrpK7VuqpELmqjAPDWvn379Pjjj+u7775zQcbGjRt19dVXq1mzZrriiiv02muved1FAAAAAEkgOCleFACQBvz9txVC8i0rNXLkqVAjQwZf+59/SmPHEmqkMFsObNGLX7yoq0dfrZE/jYwLNUJDQtWiYgv90foPTXt4GqEGgGShXbt2Sp8+vbZu3apMmTLFtdevX19fffWVp30DAAAAkHSYsQEAuDDbtkmDBkmTJ0snT55qz5hRatFC6thRKlDAyx7iImzct1EDwwdq5uqZioqJimvPmC6jnq/4vDpU7aCC2Qp62kcAON28efP09ddf66qrrgpov/baa/XXX3951i8AAAAASYtgAwCQMHaBaOBAaepUKTLyVLuNkH3xRalDBylfPi97iIuwdvdaDQgfoFm/zlJMbExce5bQLGp5U0u1u7md8mXh7wogeYqIiAiYqeG3f/9+hYWFedInAAAAAEmPYAMAcH6bN0sDBkjTp0tRp0byK3Nm6aWXpJdflvLk8bKHuAgrd6zUwB8Has66OQHtOTLkUJsqbdS6SmvlzJjTs/4BQEJUr15dM2bMUN++fd19q7MRExOjIUOG6I477vC6ewAAAABSU7Bx6NChBD82W7ZsSdoXAMA5bNok9e8vzZghRUefas+aVWrVyhY2l3Ln9rKHuAiLty/WK/Nf0f+2/i+gPXem3Gp/c3u9eNOLyp4hu2f9A4ALYQFGzZo1tXz5cp08eVKdOnXS2rVr3YyNH3/80evuAQAAAEhNwUaOHDncaKqEiI5/MQ0AkPR+/90XaLz9dmCgYUFzmzZS27ZSTkbypySxsbFa8NcC9fuhn+Zvnh+wrUCWAupYtaOeq/icModm9qyPAHAxypQpo99//11jx45V1qxZdeTIET3yyCNq2bKlClDvCQAAAEi1PAk2vvvuu7jft2zZoi5duujpp5/WLbfc4toWL16sN998UwNtLXcAwOWxfr3Ur5/07rtSzKlaC8qRwxdmWKhhvyNFBRrzNs1Tv4X9FL41PGBb4eyF1fnWznrmxmeUIV0Gz/oIAJcqe/bs6t69e0Db8ePHNWzYMHWw+k8AAAAAUh1Pgo3bbrst7vc+ffpo+PDhevLJJ+PaateurbJly+qNN95QkyZNvOgiAKQda9f6Ao333rMr4afar7hCat/et+xUdpYmSkmsCPhnGz5zgcbyf5YHbCt+RXG1vKGlXrj1BWVIT6ABIOXas2ePfvrpJ4WGhrrlqEJCQhQZGanx48e7AVJRUVEEGwAAAEAq5XnxcJudMXHixDPaK1WqpGeffdaTPgFAmrBmjWTFVj/8MDDQyJXLVxC8ZUvf8lNIMaJjojV73Wz1X9hfq3etDthWOndpda/eXY9d95j2792v0JBQz/oJAJcqPDxcDz74oKvdZ0vc2rnDtGnTVKdOHaVLl06vvPIKA6QAAACAVCzY6w4UKlRIkyZNOqN98uTJbhsAIHGl+/VXBdWrJ91wg/TBB6dCjTx5pMGDbY1AqWtXQo0UJComSjN+maHrx1+v+h/WDwg1yucvrw8f+1C/vvirGt7QUOmCPR/TAACXrEePHrr//vu1evVqtW/fXsuWLVPdunU1YMAA/fbbb2rRooUyZszodTcBAAAAJBHPr26MGDFCjz76qL788ktVqVLFtS1dulQbN27U7Nmzve4eAKQeK1YoqE8f5f7008D2fPmkjh2lFi2kzBSPTklORJ1wgcbA8IHafGBzwLYqBauoR40eeuDaB9xoZgBITdasWeOWnLruuuvilrYdMmSIHn74Ya+7BgAAACAtBBs20ur333/XhAkTtN4K10p66KGH3CgrZmwAQCJYtswKGkmff66Ay9sFCkidO0vNm0uZMnnXP1ywY5HHNHnlZA1ZNETbD20P2FajSA31rNFTNYvVJNAAkGr9+++/yp07t/vdZmZkypRJZcqU8bpbAAAAANJKsGEswLBp4wCARLRkiS/Q+PLLgOboAgUU1LWrgq2OEct0pChHTh7RxOUTNWzRMO2K2BWw7Z7i97gaGhZsAEBaYEtO7dy50/0eGxurDRs2KCIiIuAxN9iyiwAAAABSnWQRbCxcuFCvv/66/vzzT33wwQcqWLCgZs6cqWLFiqlatWpedw8AUpYff/QFGvPmBbZfdZViunTRngceUN7ChaVgz8ssIYEOHD+gsUvHasSSEdp/bH/Attola7tAo3LByp71DwC8ULNmTRdo+FkxcWOz1azdfkZHR3vYQwAAAACpNtiwOhqNGjVSw4YNtXLlSp04ccK1Hzx40M3imDt3rtddBICU4YcffIHG/PmB7RZidOsmPf20lD69tHu3Vz3EBdp7dK9GLRml0UtH69CJQ3HtQQpSvevqqVv1bq44OACkNZs3B9YVAgAAAJC2eB5s9OvXTxMnTlTjxo01a9asuPZbb73VbQMAnIeNVP3+e+nVV6UFCwK3FSvmCzQaN5ZCQ31tMTGedBMXZueRnXpt0WuasHyCIiJPLasSEhSiBmUbqGu1riqdp7SnfQQALxUpUsTrLgAAAABIy8GGrYVbo8aZ64Fnz55dBw4c8KRPAJDsWaBhMzNshsbChYHbiheXuneXnnrKN0MDKca2g9s05MchmrRykk5E+2YwmvTB6dWkXBN1qdZFxXMW97SPAAAAAAAASuvBRv78+fXHH3+oaNGiAe3h4eG6+uqrPesXACTbQMNqZ1igsWhR4LZrr5V69JAaNJDSef7POy7An//+qUHhgzR91XRFxkTGtYeFhKl5hebqeGtHFc5e2NM+AgAAAAAAJBeeX/lq3ry52rRpo6lTp7oCf//8848WL16sDh06qGfPnl53DwCST6Dx5Ze+QOOnnwK3lSol2b+X9etLISFe9RAXYf3e9RqwcIDeWfOOomNPFbjNlD6TXqj0gl6+5WUVyFrA0z4CAAAAAAAkN54HG126dFFMTIxq1qypo0ePumWpwsLCXLDRqlUrr7sHAN4HGp9/7gs0li8P3Hb99b5Ao149Ao0UZvWu1eq/sL8+WPuBYhUb154tLJtaVW6ltje3Ve5MuT3tIwAAAAAAQHLlebBhszS6d++ujh07uiWpjhw5ouuuu05ZsmTxumsA4G2g8cknvkDj558Dt5UtK/XqJT3yiBQc7FUPcRGW/b1M/Rb206cbPg1oz5kxp9pWaatWVVopR4YcnvUPAAAAAAAgJfA82HjmmWc0atQoZc2a1QUafhEREW7Ghi1RBQBpRkyM9NFHUt++0i+/BG4rX94XaDz8MIFGChO+NVz9fuinrzd9HdCeN3Nedbilg1pUaqGsYVk96x8ApCQ33nijGxyVECtXrkzy/gAAAABIg8HGm2++qUGDBrlgI75jx45pxowZBBsA0oboaGn2bF+g8euvgdsqVJB695YeesimuXnVQ1yg2NhYzd883wUaC/5aELCtYNaC6nRrJz1b4VlXTwMAkHB16tTxugsAAAAA0mqwcejQIXfRx26HDx9WhgwZ4rZFR0dr7ty5yps3r1fdA4DLF2i8/74v0Fi3LnDbTTf5Ao377yfQSEHs/2tzN851S04t2b4kYFvRHEXVtVpXNSnXRGHpwjzrIwCkZL3t/40AAAAA0jTPgo0cOXK4KeR2K1GixBnbrf3VV1/1pG8AkOSioqRZs6R+/aQNGwK33XyzL9CoVYtAIwWJiY3RR+s+coHGqp2rAraVyFVC3ap1U4OyDZQ+JL1nfQQAAAAAAEgNPFuk/bvvvtP8+fPdyNYPP/xQ3377bdwtPDxcW7dudUXFL8a4ceNUtGhRNwukSpUqWrp0aYKeN2vWLBeonD693frYq1cvFShQQBkzZtRdd92ljRs3XlTfAKRxFmi8+aZkNYUaNQoMNW69VZo3T1q0SLr3XkKNFCIqJkrvrHlHZSeUVb0P6gWEGmXyltGsR2fptxd/U5PyTQg1ACCR2UzvYcOGqXLlysqfP79y5swZcAMAAACQOnk2Y+O2225zPzdv3qzChQsnuADgf3nvvffUvn17TZw40YUaI0eOVK1atbRhw4bzLm21ZcsWdejQQdWrVz9j25AhQzR69GhXD6RYsWLq2bOne83ffvstYAktADinyEhp5kypf3/pzz8Dt9Wo4ZuhcccdhBkpSGR0pGaunqmB4QP1x/4/ArZVLFBRPWr0UO2StRUcRKF3AEgqNsN78uTJevnll9WjRw83MMqO6z/++GM3MAkAAABA6uT51RaboWEzNk73wQcfuCDhQg0fPlzNmzdX06ZNdd1117mAI1OmTOctQm4jvRo2bOhOjK6++uozZmtYOGInSg8//LBuuOEGV9T8n3/+cSdMAHBeJ09KkyZJtuRes2aBoYYFGd9/Ly1YIN15J6FGCnE86rgmLJuga8Zco2afNgsINaoWqqovG36pZc2XqU6pOoQaAJDE3n77bU2aNMkFG+nSpdOTTz7pgg4LNZYsCaxzlBSzv+29bWDUFVdc4W42szuhs8UBAAAApMAZG34DBw7U66+/fka7za547rnn1KRJkwS/1smTJ7VixQp17do1ri04ONidYCxevPicz+vTp497v2bNmmnhwoUB22xGyc6dO91r+GXPnt2d5NhrPvHEE2e83okTJ9wtfqF0ExMT425esPe1kMar94f32AcuM/s3YNo0BQ0erKCtWwM2xdasqdiePSX/DLHL+DdhP7h4EScjNGnlJA1bPEw7juwI2HZn0TvVrXo33V7kdjcD0b5juyVH7ANgH0By2A8S633tOL1s2bLu9yxZsujgwYPu9wcffNDNsk7q2d/ff/+9C1OqVq3qgpDBgwfrnnvu0dq1a1WwYMFE+IQAAAAAkmWwYbU0bHmn0xUpUsRtuxB79+51sy/y5csX0G73169ff9bnWD2PKVOmaNWqwEKv8U+W/K9x+mv6t50trDlb4fM9e/bo+PHj8urk0U707ATWwh6kPewDl8nx48r07rvKPHasQv75J2DTidtv15H27RV5002+ht27L3v32A8u3OGThzV97XS9vvp17Tu+L2BbzcI11ebGNrop/01x/84nd+wDYB9ActgPDh8+nCivc9VVV2nHjh1uadvixYtr3rx5qlChgpYtW6awsLBLmv1tLOD44osv3OzvLl26nHXGSHw2W2T27NmulmDjxo0v4ZMBAAAASNbBho18Wr16tZvuHd8vv/yiXLlyJfkJVaNGjdwU8ty5cyfa69qMERvpFX/GRqFChZQnTx5ly5ZNXp282ihi6wMXMdIm9oEkduyYXc1Q0JAhCjot0Ii97z43QyN9lSq6Qt5iP0i4/cf2a8zSMRq9dLQOHD8QsK1OyTrqXr27KhSooJSGfQDsA0gO+0Fi1amrW7euCxFsdkWrVq301FNPuUFLNkCqXbt2F/RaFzv7O76jR48qMjKSwuUAAABAag82bOp269atlTVrVtWwArqy5eYXqE2bNmdd5ul8LJwICQnRrl27Atrtfv78+c94/KZNm1xxwYceeuiMafG2Rq9NOfc/z16jQIECAa9Zvnz5s/bDRoedbYSYnRh5eQHBTl697gO8xT6QBI4elWw5vSFDbIpX4Db7t6VXLwVVqqTkVD2D/eD8dkfs1ojFIzRu2Tg3W8PP6mXUv76+W3KqTN4ySsnYB8A+AK/3g8R6z0GDBsX9Xr9+fTdzw0KIa6+9NuAYP6lmf5+uc+fOuvLKKwOWsU3IkrUAAAAAUliw0bdvXxcu1KxZ04UJ/nDBpm4PGDDggl4rNDRUFStWdKO26tSpE/dadv+ll1464/GlSpXSmjVrAtqsSLjN5Bg1apSbZZE+fXoXbthr+IMMOwH56aef9MILL1zCJweQokVESBMmSEOHnrmklP3706uXdOONXvUOF+HvQ39r2KJhen3F6zoWdSyuPSQoRI3KNVLXal1VIlcJT/sIADi/W265xd28YCHLrFmzXN2Nc81IOdeStQAAAABSWLBhYYQV6bOAw5afypgxoysAaDU2LoYtAWUFxytVqqTKlSu7gn8RERFx6+RaYGKF/Oykwk44ypQJHHWbI0cO9zN+e9u2bdWvXz838svqgVghQhuJ5Q9PAKQhtib4+PHSsGE2tDNw26OPSlaotFw5r3qHi7DlwBYN+XGIpvw8RSejT8a1h4aE6pnyz6hztc4qmiNwuUQAQPKxceNGfffdd9q9e/cZRcl72UCDJJr9Hd+wYcNcsPG///1PN9xwwwUvWQsAAAAghQUbfiVKlHC3S2VT0K14q53EWHFvm2Xx1VdfxU0pt/V2L3Tqe6dOnVw48txzz+nAgQOqVq2ae83EWhsYQApgS0WMHSu99pq0f/+p9qAg6fHHbbqXJaJe9hAXaOO+jRoYPlAzV89UVExUXHvGdBn1fMXn1aFqBxXMVtDTPgIAzs9q5dksagslLHyw5bX87PcLCTYudPa335AhQ9S/f399/fXXbnDV+ZxryVoAAAAAKSDYsFFKNkMjc+bMASOWzmb48OEX/Pp24nGukw+bGn4+06dPP6PNTor69OnjbgDSmAMHpDFjpBEjpH//PdVuAanVAereXbruOi97iAu0dvdaDQgfoFm/zlJM7KmRvVlCs6jlTS3V7uZ2ypclcH11AEDyZLOqLVSw2haJ4UJmf5vBgwe78OSdd95R0aJF3cAqkyVLFncDAAAAkIqCjZ9//lmRkZFxv59L/BFXAHBZWYgxapQ0cqR08GBgoNGwoS/QKFnSyx7iAq3csVL9F/bXnHVzAtpzZMihNlXaqHWV1sqZMadn/QMAXLh///1Xjz32WKK93oXO/p4wYYJOnjypevXqBbxO79699corryRavwAAAAAkg2DD1sA92+8A4Ll9+3xhxujRvuWn/EJCpEaNpG7dpGuv9bKHuECLty12gcYXG78IaM+dKbfa39xeL970orJnyO5Z/wAAF89CjXnz5qlFixaJ9poXMvt7y5Ytifa+AAAAAFJgjQ0A8JQVArf6GVZH48iRU+3p0klNmli1T6l4cS97iAsQGxurBX8tUL8f+mn+5vkB2wpkKaCOVTvquYrPKXNoZs/6CAC4dNdcc4169uypJUuWqGzZskqfPn3A9tatW3vWNwAAAACpLNh45JFHEvzYOXMClwwBgES1e7c0bJg0frwUEXGq3S6M2HraXbpIxYp52UNcYKAxb9M89VvYT+FbwwO2Fc5eWJ1v7axnbnxGGdJl8KyPAIDE88Ybb7haFgsWLHC305e1JdgAAAAAUidPgo3s2bMHXIT66KOPXJsV6TMrVqzQgQMHLigAAYALYsU9hw61xbGlY8dOtYeGSs2aSVaEtEgRL3uIC2BFwD/b8JkLNJb/szxgW/Eriqtb9W566oanFBoS6lkfAQCJb/PmzV53AQAAAEBaCTamTZsW93vnzp31+OOPa+LEiQqxNewlRUdH68UXX1S2bNm86B6A1Oyff6QhQ6TXX5eOHw8MNJo39wUahQp52UNcgOiYaM1eN9vV0Fi9a3XAttK5S6t79e6qX6a+0gWz8iIAAAAAAEBq4fmVnqlTpyo8PDwu1DD2e/v27VW1alUNtRHVAHCptm+XBg+WJk2STpw41Z4hg/T881LHjlLBgl72EBcgMjpS7/76rgYsHKAN+zYEbCufv7x6VO+huqXrKjgo2LM+AgCShp0n9O3bV5kzZ3a/n8/w4cMvW78AAAAApKFgIyoqSuvXr1fJkiUD2q0tJibGs34BSCW2bpUGDZKmTJFOnjzVnjGj9MILUocOUoECXvYQF+BE1Am9+cubGhQ+SJsPBC4/UqVgFfWo0UMPXPuAW1cdAJA6/fzzz4qMjIz7/Vz4fwEAAACQenkebDRt2lTNmjXTpk2bVLlyZdf2008/adCgQW4bAFyULVukgQNt7Tvp/y9+OJkySS1bSi+/LOXL52UPcQGORR7T5JWTNWTREG0/tD1gW40iNdSzRk/VLFaTi1gAkAZ89913+vPPP12NPvsdAAAAQNrjebAxbNgw5c+fX6+99pp27Njh2goUKKCOHTvqZbvwCAAX4s8/pQEDpDfftClhp9qzZJFeesnWr5Dy5PGyh7gAR04e0YRlE/Ta4te0K2JXwLZ7it/jamhYsAEASFuuvfZad+6QN29ed79+/foaPXq08jFoAQAAAEgTPA82goOD1alTJ3c7dOiQa6NoOIAL9scfUv/+0syZUnT0qfasWaXWraV27aRcubzsIS7AgeMHNHbpWI1YMkL7j+0P2Fa7ZG0XaFQu6JvlBwBIe2JjYwPuz507VwNtpiYAAACANMHzYMNfZ+P77793y1E1aNDAtf3zzz8u4Mhio6wB4Fx+/13q1096+20pfl2e7NmlNm18t5w5vewhLsDeo3s1cslIjVk6RodO+MJuE6Qg1buunrpV7+aKgwMAAAAAACDt8jzY+Ouvv3Tvvfdq69atOnHihO6++25lzZpVgwcPdvcnTpzodRcBJEfr1vkCjVmzAgONHDl8szNslob9jhRh55Gdem3Ra5qwfIIiIiPi2kOCQtSgbAN1rdZVpfOU9rSPAIDkw2oqnV5XiTpLAAAAQNrhebDRpk0bVapUSb/88otyxVsmpm7dumrevLmnfQOQDK1dK/XtK73/vq1DcardZmVY/Qyro2GzNZAibDu4TUN+HKJJKyfpRPSJuPb0wenVpFwTdanWRcVzFve0jwCA5LkU1dNPP62wsDB3//jx42rRooUyZ84c8Lg5c+Z41EMAAAAAqTrYWLhwoRYtWqTQ0NCA9qJFi+rvv//2rF8AkpnVq32BxocfBrZbINqhg9Sypa+eBlKEP//9U4PCB2n6qumKjImMaw8LCVPzCs3V8daOKpy9sKd9BAAkX02aNAm4/9RTT3nWFwAAAABpMNiIiYlRdPxCv/9v+/btbkkqAGncqlVSnz7SRx8FtufJI3XsKL3wgkQtnhRj/d71GrBwgN5Z846iY0/9258pfSa9UOkFvXzLyyqQtYCnfQQAJH/Tpk3zugsAAAAA0nKwcc8992jkyJF644034tbGPXLkiHr37q3777/f6+4B8MqKFb5A49NPA9vz5ZM6dZKef146bbkJJF+rd61W/4X99cHaDxSrU0uIZQvLplaVW6ntzW2VO1NuT/sIAAAAAACAlMHzYGPYsGGuePh1113n1sZt0KCBNm7cqNy5c+vdd9/1unsALrelS32BxhdfBLYXKCB17iw995yUMaNXvcMFWvb3MvVb2E+fbggMqHJmzKm2VdqqVZVWypGBIu8AAAAAAABIQcFGoUKFXOHw9957z/202RrNmjVTw4YNlZGLl0DasXixL9D46qvA9oIFpS5dpGeflTJk8Kp3uEDhW8PV74d++nrT1wHteTPnVYdbOqhFpRbKGsZygwAAAAAAAEhhwUZkZKRKlSqlzz//3AUZdgOQxoSH+wKNb74JbC9USOraVXrmGSkszKve4QLExsZq/ub5LtBY8NeCgG0FsxZUp1s76dkKz7p6GgAAAAAAAECKDDbSp0/vlp8CkAYtWOALNL79NrC9SBGpWzepSRMCjRQUaMzdONctObVk+5KAbUVzFFXXal3VpFwThaXj7wkAAAAAAIBUsBRVy5YtNXjwYE2ePFnp0nneHQBJKTZW+v576dVXfcFGfMWKSd27S40aSaGhXvUQFyAmNkYfrfvIBRqrdq4K2FYiVwl1q9ZNDco2UPqQ9J71EQAAAAAAAKmP50nCsmXLNH/+fM2bN09ly5ZV5syZA7bPmTPHs74BSMRAY/58X6BhS0/Fd801vkDDlqJLzwXwlCAqJkrvr31f/Rf21297fgvYViZvGfWo3kP1rqunkOAQz/oIAAAAAACA1MvzYCNHjhx69NFHve4GgKQKNL7+2rfklBUHj69ECalHD+nJJyVma6UIkdGRmrl6pgaGD9Qf+/8I2FaxQEX1qNFDtUvWVnBQsGd9BAAAAAAAQOrn+dXEadOmed0FAEkRaMyd6ws0li4N3FaqlNSzp1S/vhTCiP6U4HjUcU37eZoG/ThIWw9uDdhWtVBV9azRU7WK11JQUJBnfQQAAAAAAEDa4VmwERMTo6FDh+rTTz/VyZMnVbNmTfXu3VsZM2b0qksAEiPQ+OwzX6CxYkXgtuuv9wUa9eoRaKQQEScj9MaKNzR00VDtOLIjYNudxe50S07dXvR2Ag0AAAAAAACkjWCjf//+euWVV3TXXXe5MGPUqFHavXu3pk6d6lWXAFysmBjpk098gcaqwCLSKltW6tVLeuQRKZglilKCQycOafyy8Rq+eLj2HN0TsO3+a+9X9+rd3UwNAAAAAAAAIE0FGzNmzND48eP1/PPPu/v/+9//9MADD2jy5MkK5uInkHICjTlzpL59pdWrA7eVL+8LNB5+mEAjhdh/bL9G/zRao34apQPHDwRsq1uqrgs0Kl5Z0bP+AQAAAAAAAJ4GG1u3btX9998fd99mbthyJv/884+uuuoq/jpAchYdLX34oS/QWLs2cFvFir5A46GHJJYoShF2R+zWiMUjNG7ZOB0+eTiu3YqA17++vrpV76Yyect42kcAAAAAAADA82AjKipKGTJkCGhLnz69IiMjveoSgIQEGu+9J/XrJ61bF7jtppuk3r0lCywJNFKEvw/9rWGLhun1Fa/rWNSxuPaQoBA1KtdIXat1VYlcJTztIwAAAAAAAJBsgo3Y2Fg9/fTTCgsLi2s7fvy4WrRoocyZM8e1zbFlbgB4KypKevddX6Dx+++B226+2Rdo1KpFoJFCbDu8Ta8uf1VTV03VyeiTce2hIaF6pvwz6lyts4rmKOppHwEAAAAAAIBkF2w0adLkjLannnrKk74AOAebQfX221L//tIffwRuq1bNF2jUrEmgkUJs3LdRAxYO0Ftr3lJUTFRce8Z0GfV8xefVoWoHFcxW0NM+AgAAAAAAAMk22Jg2bZpXbw0gIYHGjBnSgAHSn38GbrvtNl+gcfvtBBopxNrdazUgfIBm/TpLMbExce1ZQrOo5U0t1e7mdsqXJZ+nfQQAAAAAAACSfbABIBk6eVKaPt0XaPz1V+C2O+/0FQW3YAMpwsodK9V/YX/NWRe4pF/20Oxqc3Mbd8uZMadn/QMAAAAAAAAuBsEGAOnECWnqVGngQGnbtsBtd9/tCzRs6SmkCIu3LXaBxhcbvwhoz50pt9pVaad6RerpmkLXKDg42LM+AgAAAAAAABeLYANIy44flyZPlgYNkv7+O3Dbvff6Ao1bbvGqd7gAsbGxWvDXAvX7oZ/mb54fsK1AlgLqWLWjnqv4nKunsXv3bs/6CQAAAAAAAFwqgg0gLTp2THrjDWnwYGnHjsBtDzwg9ewpVaniVe9wgYHG15u+doHGj9t+DNhWOHthdb61s5658RllSJfBtcXEnKqxAQAAAAAAAKREBBtAWnL0qDRihDR0qLRrV+C22rV9MzQqVvSqd7gAVgT8sw2fqd/Cflr+z/KAbcWvKK5u1bvpqRueUmhIqGd9BAAAAAAAAJICwQaQFhw5Io0frzxDhyp4797AbXXr+mZo3HijV73DBYiOidaHv33oamis2b0mYFvp3KXVvXp31S9TX+mC+ecdAAAAAAAAqRNXvoDU7PBhadw46bXXzgw06tXzBRo33OBV73ABIqMj9e6v72rAwgHasG9DwLby+curR/Ueqlu6roKDKAgOAAAAAACA1I1gA0iNDh6Uxo6Vhg+X9u+Pa44NCpIee0xBFmiUKeNpF5EwJ6JO6M1f3tSg8EHafGBzwLYqBauoR40eeuDaBxRkf1sAAAAAAAAgDSDYAFKTAwek0aN9dTTsd7/gYMXWr6+9LVooV7VqCgpmVH9ydyzymCavnKwhi4Zo+6HtAdtqFKmhnjV6qmaxmgQaAAAAAAAASHMINoDUwGZljBrlu9lsDT8LMBo2lLp3V+y11yp6924ve4kEOHLyiCYsm6DXFr+mXRGBBd7vKX6Pq6FhwQYAAAAAAACQVhFsACnZvn2+2Rk2S8PqafiFhEiNGrlAQ9dc42uLifGsm/hvB44f0NilYzViyQjtP3Zq+TBTu2RtF2hULljZs/4BAAAAAAAAyQXBBpAS7dnjq59hdTSOHDnVni6d1KSJ1K2bdPXVXvYQCbT36F6NXDJSY5aO0aETh+LagxSketfVU7fq3VxxcAAAAAAAAAA+BBtASmJLSQ0bJo0fL0VEnGpPn15q2lTq2lUqWtTLHiKBdh7ZqdcWvaYJyycoIvLU3zIkKEQNyjZQ12pdVTpPaU/7CAAAAAAAACRHBBtASrBzpzR0qDRhgnTs2Kn20FCpWTOpSxepcGEve4gE2nZwm4b8OESTVk7SiegTce3pg9OrSbkm6lKti4rnLO5pHwEAAAAAAIDkjGADSM7++UcaPFh64w3p+PFT7WFhUvPmUufO0lVXedlDJNCf//6pQeGDNH3VdEXGRMa1h4WEqXmF5up4a0cVzk44BQAAAAAAAPwXgg0gOdq+XRo0SJo8WTpxalS/MmSQnn9e6tRJuvJKL3uIBFq/d70GLBygd9a8o+jY6Lj2TOkz6YVKL+jlW15WgawFPO0jAAAAAAAAkJIQbADJydat0sCB0tSp0smTp9ozZpReeEHq2FHKn9/LHiKBVu9arf4L++uDtR8oVrFx7dnCsqlV5VZqe3Nb5c6U29M+AgAAAAAAACkRwQaQHGzZ4gs0pk2TIk8tU6RMmaSWLaUOHaS8eb3sIRJo2d/L1G9hP3264dOA9pwZc6ptlbZqVaWVcmTI4Vn/AAAAAAAAgJSOYAPw0p9/SgMGSG++KUVFnWrPkkV66SWpfXspTx4ve4gECt8arn4/9NPXm74OaM+bOa863NJBLSq1UNawrJ71DwAAAAAAAEgtCDYAL2zc6As0Zs6Uok/VXVDWrFLr1lK7dlKuXF72EAkQGxur+Zvnu0BjwV8LArYVzFpQnW7tpGcrPOvqaQAAAAAAAABIHAQbwOW0YYPUv7/09ttSTMyp9uzZpbZtpTZtpCuu8LKHSGCgMXfjXLfk1JLtSwK2Fc1RVF2rdVWTck0Uli7Msz4CAAAAAAAAqVWwUqFx48apaNGiypAhg6pUqaKlS5ee87Fz5sxRpUqVlCNHDmXOnFnly5fXTBtFH8+uXbv09NNP68orr1SmTJl07733aqONuAcS6rffpIYNpeuu883S8IcaFmL06eOrsfHKK4QayVxMbIxm/zZbFd6ooAfffTAg1CiRq4SmPzxdv7/0u56r+ByhBgAAAAAAAJBEUt2Mjffee0/t27fXxIkTXagxcuRI1apVSxs2bFDesxRfzpkzp7p3765SpUopNDRUn3/+uZo2beoea8+zkdl16tRR+vTp9cknnyhbtmwaPny47rrrLv32228uDAHO6ddfpb59pQ8+sGH+p9pz5pReftlXRyNbNi97iASIionS+2vfV/+F/fXbnt8CtpXJW0Y9qvdQvevqKSQ4xLM+AgAAAAAAAGlFqgs2LHRo3ry5CyeMBRxffPGFpk6dqi5dupzx+Ntvvz3gfps2bfTmm28qPDzcBRs2M2PJkiX69ddfdf3117vHTJgwQfnz59e7776rZ5999jJ9MqQoq1f7ZmLMnh3Ynju31KGD9OKLvnoa+D/27gM8iqpr4PhJAqETepXem5QgSFdAEFCKKNggIEUElCJIEUGkSW/SBAUEEQQB0RdBpPfepItIk95CJ2W/59x8s+6mkUCSzSb/3/Msyc7Mzt6ZvVl275lzT7wWEBQgcw7MkWGbhslf1/9yWueb3Vf6Ve8nDYs0FE+PBJn8BgAAAAAAAMRLCWo07tGjR7J7926TTWHx9PQ097du3Rq1QsCrV5vsjurVq5tlDx8+ND91WivHfSZLlswEPwAne/eKNGkiUrq0c1BDs4VGjhQ5dUqkVy+CGvHcg8AHMmXnFCk4saC0WdbGKahROVdl+e2d32Rnu53SuGhjghoAAAAAAABAHEtQGRtXr16VoKAgyZo1q9NyvX/06NEIH3fr1i3JmTOnCWJ4eXnJ5MmT5aWXXjLrdIqq3LlzS58+fWTatGlm6qmxY8fKuXPn5MKFC+HuT/djBUSUv7+/+RkcHGxurqDPq4EbVz1/grdrl3gMGiQev/7qtNiWLZvYevYUad9eJGXKkIX0gXjr7qO7Mn3PdBm1dZRcuOP8910zb03pW62vvJDnBfHw8DDnUm/uhn4A+gDoA4gP/YD+BwAAAOBpJKjAxpNKkyaN7Nu3T+7cuWMyNrRGR/78+c00VVpbQwuMt2nTxtTj0MCHZoDUq1cvwkHNYcOGycCBA8Msv3Llijx48EBc9eVRAzjaZs04QcxIunevpBo9WpKvXu20PChrVrnbubPc04LhKVKI3LkTcnMh+kDEbj+6LbMOzZJpB6bJtQfXnNbVyl1LupTtIs9le87+d+zO6AegD4A+gPjQD27fvh3nzwkAAAAg4UhQgY1MmTKZwMOlS5eclut9rYkREf0yV7BgQfN7mTJl5MiRIyY4YdXf8PX1NYEP/fKn011lzpzZFCYvX758uPvT7A4NjjhmbOTKlcs8TouPu+rLq15lrm1gECMGbN0qHl98IR6//+602JYzp9h69xaP996T1MmTS2qJP+gDYV2/f10m7pgoE3ZMkJsPbjqta1ykscnQ0FoaCQn9APQB0AcQH/qB4zSvAAAAAJCoAxve3t4mCKFZF40bN7Z/adP7nTt3jvJ+9DGOU0lZfHx8zE8tKL5r1y4ZNGhQuI/X+ht6C02/NLpyAEG/vLq6DW5P66poNs4ffzgvz51bI1ri0bq1eITz2scX9IEQl+9elrFbx8qknZNMtoZF62U0L9HcBDRKZikpCRX9APQB0Afg6n5A3wMAAADwNBJUYENppoSfn5/JpqhQoYKMGzdO7t69K61btzbrW7ZsaeppaEaG0p+6bYECBUwwY/ny5TJnzhyZMmWKfZ8LFy40V7NprY2DBw9Kly5dTOCkTp06LjtOxLF160S++EJk7Vrn5XnzivTtK+Lnp5E1V7UOUXTe/7yM2jJKpu2eJvcD79uXe3l4SYvSLaRP1T5SOGNhl7YRAAAAAAAAQCILbDRv3tzMgd+/f3+5ePGimVpqxYoV9oLiZ86ccbpCTIMeHTt2NMXAU6RIYYqFz5071+zHokXCNWCiU1plz57dBEc+++wzlxwf4pDWUNFAhmZobNjgvC5/fpFPPxVp0UIkaVJXtRBR9M/Nf2T4puHy7b5v5VHQI/tyby9vea/Me9Krai/Jmy6vS9sIAAAAAAAAIJEGNpROOxXR1FPr9Mp7B4MHDza3yHz00UfmhkQU0NCppjSgsXmz8zqtxdKvn8jbbxPQcAMnrp2QYZuGyZwDcyQwONC+PEWSFPK+7/vSo3IPyZk2p0vbCAAAAAAAACB6EmRgA3jigMbKlSEBjW3bnNcVKRIS0HjzTZEk/NnEd4cuH5IhG4fIgkMLJNgWbF+e2ju1dHquk3R7vptkTR2SxQUAAAAAAADAvTBCC2hAY/nykBoaO3Y4rytWTESnHWvWTMTLy1UtRBTtubDHBDQWH1nstDxd8nTSpWIX+ajiR5IhRQaXtQ8AAAAAAADA0yOwgcQd0Pjll5CAxu7dzutKlBDp31+kaVMCGm5g69mtMnjjYFl+YrnT8kwpM0n357tLx+c6ik9yH5e1DwAAAAAAAEDMIbCBxCc4WOTnn0MCGvv2Oa979tmQgEaTJiIOReYR/9hsNll/er0M3jBYVp9a7bQue+rs0rNyT2nv215SeadyWRsBAAAAAAAAxDwCG0hcAY3Fi0UGDRI5cMB5XdmyIQGNhg0JaLhBQGPlyZUmoLH5rHNx99w+uaVXlV7yXtn3JHmS5C5rIwAAAAAAAIDYQ2ADCV9QkMjChSEBjcOHndeVLx8S0HjlFREPD1e1EFGgRcB/OfaLmXJq17+7nNYVSF9A+lbrK+8++654e3m7rI0AAAAAAAAAYh+BDSTsgMb8+SKDB4scPeq8rkIFkQEDROrVI6ARzwUFB8miw4tMUfCDlw86rSuWqZh8Wu1TaV6yuSTx5O0MAAAAAAAASAwYCUTCExgoMm+eyJAhIsePO6+rVCkkoFGnDgGNeC4gKEB++PMHGbpxqBy7dsxpXZlsZaRftX7SpFgT8fRg6jAAAAAAAAAgMSGwgYQjIEBk7tyQgMbJk87rqlYNCWjUqkVAI557GPhQZu+fLV9u+lJO3TzltK5izorSr3o/aVCogXjwOgIAAAAAAACJEoENuL9Hj0S++05k6FCRU84D4VKjRkhA44UXCGjEc/cD7suMPTNkxJYRcs7/nNO66nmqy2fVP5Na+WoR0AAAAAAAAAASOQIbcO+AxsyZIsOGiZw+7byuZs2QouAa2EC8dufRHZmyc4qM3jpaLt295LSuToE6poaGBjYAAAAAAAAAQBHYgPt5+FDkm29EvvxS5OxZ53UvvRQS0NCppxCv3XxwU77a8ZWM3TZWrt+/7rSuYZGGJqBRIWcFl7UPAAAAAAAAQPxEYAPu48EDkenTRYYPFzl/3nldvXoin30WUhwc8drVe1dl3LZxMnHHRPF/6G9f7iEe8nrx16Vvtb6mODgAAAAAAAAAhIfABuK/e/dEvv5aZMQIkQsXnNe98kpIQKMCV/bHdxfvXJTRW0bLlF1T5G7AXftyLw8vebvU29Knah8plrmYS9sIAAAAAAAAIP4jsIH46+5dkalTRUaOFLnkXHtBGjUKCWj4+rqqdYiis7fOyojNI2T6nunyMOihfXlSz6TiV9pPelftLQUyFHBpGwEAAAAAAAC4DwIbiH/u3BGZPFlk1CiRK1ec1732WkhAowxTFcV3f9/4W77c9KXM2jdLAoID7MuTeSWTduXaSc8qPSW3T26XthEAAAAAAACA+yGwgfjj9m2Rr74SGT1a5Nq1/5Z7eIi8/rpIv34izz7ryhYiCo5ePSpDNw6VeQfnSZAtyL48ZdKU8kH5D+TjSh9L9jTZXdpGAAAAAAAAAO7L09UNAOTWLZHBg0Xy5hXp2/e/oIYGNN58U+TgQZEffySoEc8duHRAmi9qLsUnFZc5B+bYgxppk6WVT6t9Kqe7npZRdUYR1AAAAPHWpEmTJG/evJI8eXKpWLGi7NixI8JtDx06JE2bNjXbe3h4yLhx4+K0rQAAAEBiRsYGXOfmTZHx40X0S6D+bvH0FHnrLZFPPxUpRjHp+G7n+Z0yeONgWXZsmdPyDCkySNeKXeXDih9KuuTpXNY+AACAqFiwYIF0795dpk6daoIaGqioW7euHDt2TLJkyRJm+3v37kn+/PnljTfekG7durmkzQAAAEBiRWADce/69ZBghgY1/P2dAxrvvhuStVGkiCtbiCjYdGaTDN4wWFaeXOm0PEuqLNKjUg/pUL6DpEmWxmXtAwAAiI4xY8ZIu3btpHXr1ua+Bjj+97//ybfffiu9e/cOs/1zzz1nbiq89QAAAABiD4ENxJ2rV0XGjhWZODGknobFy0ukZcuQgEbBgq5sIR7DZrPJ6lOrTUBj/en1Tutypskpn1T5RNqWa2vqaQAAALiLR48eye7du6VPnz72ZZ6enlK7dm3ZunVrjD3Pw4cPzc3i73iRDwAAAIAoI7CB2HflSkhBcC0Mfvfuf8uTJBFp1UpEv0Dmz+/KFiIKAY3lJ5abKae2ndvmtC5vurzSp2of8SvtJ8mSJHNZGwEAAJ7U1atXJSgoSLJmzeq0XO8fPXo0xp5n2LBhMnDgwBjbHwAAAJBYEdhA7Ll0SWTUKJHJk3US4v+WJ00q8t57IQGNPHlc2UI8RrAtWJYcWWICGvsu7nNaVzhjYelbta+8XeptSeqV1GVtBAAAcBeaEaJ1PBwzNnLlyuXSNgEAAADuiMAGYt6FCyIjR+rExCL37/+33NtbpG1bnYRYhC9w8VpgcKD8eOhHGbJxiBy+cthpXcksJaVftX7yevHXxcvTy2VtBAAAiCmZMmUSLy8vuaQX5jjQ+9myZYux50mWLJm5AQAAAHg6BDYQc86fFxkxQuTrr0UePPhvuX55a99e5JNPRJ55xpUtxGM8Cnokcw/MlWGbhslf1/9yWueb3Vf6Ve8nDYs0FE8PT5e1EQAAIKZ5e3uLr6+vrF69Who3bmyWBQcHm/udO3d2dfMAAAAAhEJgA0/v7FmR4cNFZszQioj/LU+eXKRDB5GePUVy5HBlC/EYDwIfyLd7v5Xhm4fLmVtnnNZVzlVZPqv+mdQtUFc8PDxc1kYAAIDYpFNE+fn5Sfny5aVChQoybtw4uXv3rrRu3dqsb9mypeTMmdPUybAKjh8+fNj++/nz52Xfvn2SOnVqKViwoEuPBQAAAEjoCGzgyZ0+LfLllyLffqvf5v5bniKFSMeOIj16iMRg6j5i3t1Hd+Xr3V/LyC0j5cKdC07rauaraaaceiHvCwQ0AABAgte8eXO5cuWK9O/fXy5evChlypSRFStW2AuKnzlzRjw9/8ta/ffff6Vs2bL2+6NGjTK3GjVqyLp161xyDAAAAEBiQWAD0XfqlIheqTZrlkhAwH/LU6US6dRJ5OOPRbJkcWUL8Rj+D/1l0o5JMmbbGLl676rTuvqF6sun1T41mRoAAACJiU47FdHUU6GDFXnz5hWbzRZHLQMAAADgiMAGou7kSZGhQ0W++04kMPC/5alTi3z4oebva+VFV7YQj3HjwQ2Zsn6KTNgxQW4+uOm0rknRJiag4ZvD12XtAwAAAAAAAIDHIbCBxztxQmTIEJG5c0WCgv5bnjatyEcfiXTrJpIhgytbiMe4fPeyjN4yWibtnCR3A+7al2sR8OYlmkvfan2lZJaSLm0jAAAAAAAAAEQFgQ1E7OjRkIDGvHkiwcH/LffxEenaVaRLF5H06V3ZQjzGef/zMmrLKJm2e5rcD7xvX+7l4SUtSreQPlX7SOGMhV3aRgAAAAAAAACIDgIbCOvwYZHBg0XmzxdxnDdYgxianaFZGhrcQLz1z81/ZPim4fLtvm/lUdB/hd29Pb2lddnW0rtqb8mbLq9L2wgAAAAAAAAAT4LABv5z8GBIQGPhQueAhk4zpQXBtZCiTj+FeOvEtRMybNMwmXNgjgQG/1cHJUWSFNLet734FfKT0vlKi6enp0vbCQAAAAAAAABPisAGRPbvFxk0SOSnn5yXayHwHj1EOnYUSZPGVa1DFBy6fEiGbBwiCw4tkGDbf9OGpfZOLZ2e6yTdnu8mmVNmlsuXL7u0nQAAAAAAAADwtAhsJGZ79oQENJYudV6eJYtIz54iH3wgkiqVq1qHKNhzYY8JaCw+sthpebrk6aRLxS7yUcWPJEOKkMLuwY51UgAAAAAAAADATRHYSOjOnBG5etUU/05y/XrItFJHjojMni2yerXzttmyiXzyicj774ukTOmqFiMKtp7dKoM3DpblJ5Y7Lc+UMpN0f767dHyuo/gkpw4KAAAAAAAAgISHwEZCD2oUKSLy4IFoRYVMEW2XI4dIr14i7dqJpEgRt21ElNlsNll/er0M3jBYVp9yDkplT51delbuaepopPImywYAAAAAAABAwkVgIyHTTI0HDyJer1NO9e8v0qaNSPLkcdkyRDOgsfLkShPQ2Hx2s9O63D65pVeVXvJe2fckeRJeQwAAAAAAAAAJH4GNxOznn0Wef97VrUAEtAj4L8d+MVNO7fp3l9O6AukLSN9qfeXdZ98Vby9vl7URAAAAAAAAAOIagY3EzJsB8fgoKDhIFh1eZIqCH7x80GldsUzF5NNqn0rzks0liSd/vgAAAAAAAAASH0ZGgXgiIChAfvjzBxm6cagcu3bMaV2ZbGWkX7V+0qRYE/H00IopAAAAAAAAAJA4EdgAXOxh4EOZvX+2fLnpSzl185TTuoo5K0q/6v2kQaEG4uHh4bI2AgAAAAAAAEB8QWAjIcuUKaQoeHgFxHW5rofL3A+4LzP2zJARW0bIOf9zTuuq56kun1X/TGrlq0VAAwAAAAAAAAAcENhIyHLnFjl2TOTqVQkODpbr169LhgwZxNPTMySooesR5+48uiNTdk6R0VtHy6W7l5zW1SlQx9TQ0MAGAAAAAAAAACAsAhsJnQYv9BYcLIGXL4tkySKigQ3EuZsPbspXO76SsdvGyvX7153WNSzS0AQ0KuSs4LL2AQAAAAAAAIA7ILABxLKr967KuG3jZOKOieL/0N++3EM85PXir0vfan1NcXAAAAAAAAAAwOMR2ABiycU7F2X0ltEyZdcUuRtw177cy8NL3i71tvSp2keKZS7m0jYCAAAAAAAAgLshsAHEsLO3zsqIzSNk+p7p8jDooX15Us+k4lfaT3pX7S0FMhRwaRsBAAAAAAAAwF0R2ABiyN83/pYvN30ps/bNkoDgAPvyZF7JpF25dtKzSk/J7UPBdgAAAAAAAAB4GgQ2gKd09OpRGbpxqMw7OE+CbEH25SmTppQPyn8gH1f6WLKnye7SNgIAAAAAAABAQkFgA3hCBy4dkCEbh8jCQwvFJjb78rTJ0sqHFT6Urs93lUwpM7m0jQAAAAAAAACQ0BDYAKJp5/mdMnjjYFl2bJnT8gwpMkjXil3lw4ofSrrk6VzWPgAAAAAAAABIyAhsAFG06cwmGbxhsKw8udJpeZZUWaRHpR7SoXwHSZMsjcvaBwAAAAAAAACJAYENIBI2m01Wn1ptAhrrT693WpczTU75pMon0rZcW1NPAwAAAAAAAAAQ+whsABEENJafWC6DNgyS7ee3O63Lmy6v9KnaR/xK+0myJMlc1kYAAAAAAAAASIw8JQGaNGmS5M2bV5InTy4VK1aUHTt2RLjt4sWLpXz58pIuXTpJlSqVlClTRubMmeO0zZ07d6Rz587yzDPPSIoUKaR48eIyderUODgSxLVgW7D8dPgnKfd1OXnlh1ecghqFMxaWWY1myfHOx6W9b3uCGgAAAAAAAADgAgkuY2PBggXSvXt3E3jQoMa4ceOkbt26cuzYMcmSJUuY7TNkyCCffvqpFC1aVLy9veXXX3+V1q1bm231cUr3t2bNGpk7d64JmPz+++/SsWNHyZEjhzRs2NAFR4mYFhgcKAv+XCBDNw2Vw1cOO60rmaWk9KvWT14v/rp4eXq5rI0AAAAAAAAAgASYsTFmzBhp166dCU5YmRUpU6aUb7/9NtztX3jhBWnSpIkUK1ZMChQoIF26dJFnn31WNm3aZN9my5Yt4ufnZ7bVwEb79u2ldOnSkWaCwD08Cnok3+79VopNKibvLnnXKajhm91XljRfIvs77JfmJZsT1AAAAAAAAACAeCBBZWw8evRIdu/eLX369LEv8/T0lNq1a8vWrVujVFdBMzM0u2P48OH25ZUrV5Zly5bJe++9Z7I01q1bJ8ePH5exY8eGu5+HDx+am8Xf39/8DA4ONjdX0OfV43PV88c3DwIfyMx9M2XElhFy5tYZp3WVn6ksn1b7VOoWqCseHh4itpApqtwdfQCKfgD6AOgDiA/9gP4HAAAA4GkkqMDG1atXJSgoSLJmzeq0XO8fPXo0wsfdunVLcubMaYIRXl5eMnnyZHnppZfs6ydOnGiyNLTGRpIkSUywZPr06VK9evVw9zds2DAZOHBgmOVXrlyRBw8eiKu+POpx6hdYbX9idS/gnsw5Mkem7J8il+5dclpXNUdV6Vquq1TOUdkENPT1SkjoA1D0A9AHQB9AfOgHt2/fjvPnBAAAAJBwJKjAxpNKkyaN7Nu3zxQJX716tampkT9/fjP1lBXY2LZtm8nayJMnj2zYsEE6depksjc0GyQ0zRjRfThmbOTKlUsyZ84sadOmFVd9edXBem1DYhzE8H/oL5N3Tpax28fK1XtXndbVK1hP+lbtK5VzVZaELLH3AYSgH4A+APoA4kM/SJ48eZw/JwAAAICEI0EFNjJlymQyLi5dcr4SX+9ny5Ytwsfpl7mCBQua38uUKSNHjhwxWRca2Lh//7707dtXlixZIg0aNDDbaA0ODYSMGjUq3MBGsmTJzC2853HlAIJ+eXV1G+La9fvXZcL2CTJ++3i5+eCm07omRZuYKad8c/hKYpEY+wDCoh+APgD6AFzdD+h7AAAAAJ5GggpseHt7i6+vr8m6aNy4sf1qNL3fuXPnKO9HH2PVyAgICDC30F++NIDC3MDx1+W7l2XM1jEyaeckufPojn25p4enNC/RXPpW6ysls5R0aRsBAAAAAAAAAIk8sKF0Cig/Pz8pX768VKhQQcaNGyd3796V1q1bm/UtW7Y09TQ0I0PpT922QIECJpixfPlymTNnjkyZMsWs16mjatSoIT179pQUKVKYqajWr18v3333nYwZM8alx4qwzvufl1FbRsm03dPkfuB9+3IvDy9pUbqF9KnaRwpnLOzSNgIAAAAAAAAAnlyCC2w0b97cFH3u37+/XLx40UwttWLFCntB8TNnzjhlX2jQo2PHjnLu3DkTuChatKjMnTvX7Mcyf/58UzfjnXfekevXr5vgxpAhQ6RDhw4uOUaE9c/Nf2T4puHy7b5v5VHQI/tyby9vea/Me9Krai/Jmy6vS9sIAAAAAAAAAHh6CS6woXTaqYimnlq3bp3T/cGDB5tbZLQ+x8yZM2O0jYgZJ66dkGGbhsmcA3MkMDjQvjxFkhTyvu/70qNyD8mZNqdL2wgAAAAAAAAAiDkJMrCBhO/Q5UMyZOMQWXBogQTb/qt1kto7tXR6rpN0e76bZE0dkqUDAAAAAAAAAEg4CGzArey5sMcENBYfWey0PF3ydNKlYhf5qOJHkiFFBpe1DwAAAAAAAAAQuwhswC1sPbtVBm8cLMtPLHdanillJun+fHfp+FxH8Unu47L2AQAAAAAAAADiBoENxFs2m03Wn14vgzcMltWnVjuty546u/Ss3FPa+7aXVN6pXNZGAAAAAAAAAEDcIrCBeBnQWHlypQlobD672Wldbp/c0qtKL3mv7HuSPElyl7URAAAAAAAAAOAaBDYQb2gR8F+O/WKmnNr17y6ndQXSF5C+1frKu8++K95e3i5rIwAAAAAAAADAtQhswOWCgoNk0eFFpij4wcsHndYVy1RMPq32qTQv2VySeNJdAQAAAAAAACCxY6QYLhMQFCA//PmDDN04VI5dO+a0rky2MtKvWj9pUqyJeHp4uqyNAAAAAAAAAID4hcAG4tzDwIcye/9s+XLTl3Lq5imndRVzVpR+1ftJg0INxMPDw2VtBAAAAAAAAADETwQ2EGfuB9yXGXtmyIgtI+Sc/zmnddXzVJfPqn8mtfLVIqABAAAAAAAAAIgQgQ3EujuP7siUnVNk9NbRcunuJad1dQrUMTU0NLABAAAAAAAAAMDjENhArLn54KZ8teMrGbttrFy/f91pXcMiDU1Ao0LOCi5rHwAAAAAAAADA/RDYQIy7eu+qjNs2TibumCj+D/3tyz3EQ14v/rr0rdbXFAcHAAAAAAAAACC6CGwgxly8c1FGbxktU3ZNkbsBd+3LvTy85O1Sb0ufqn2kWOZiLm0jAAAAAAAAAMC9EdjAUzt766yM2DxCpu+ZLg+DHtqXJ/VMKn6l/aR31d5SIEMBl7YRAAAAAAAAAJAwENjAE/v7xt8ybOMwmb1/tgQEB9iXJ/NKJu3KtZOeVXpKbp/cLm0jAAAAAAAAACBhIbCBaDty5YgM2zRM5h2cJ0G2IPvylElTygflP5CPK30s2dNkd2kbAQAAAAAAAAAJE4ENRNmBSwdk8IbBsujwIrGJzb48bbK08mGFD6Xr810lU8pMLm0jAAAAAAAAACBhI7CBx9pxfocM2ThElh1b5rQ8Q4oM0rViV/mw4oeSLnk6l7UPAAAAAAAAAJB4ENhAhDad2SSDNgyS30/+7rQ8S6os0qNSD+lQvoOkSZbGZe0DAAAAAAAAACQ+BDbgxGazyepTq82UU+tPr3dalzNNTvmkyifStlxbU08DAAAAAAAAAIC4RmAD9oDG8hPLTYbG9vPbndblTZdX+lTtI36l/SRZkmQuayMAAAAAAAAAAAQ2ErlgW7AsObJEBm8cLPsu7nNaVzhjYelbta+8XeptSeqV1GVtBAAAAAAAAADAQmAjkQoMDpQFfy6QoZuGyuErh53WlcxSUvpV6yevF39dvDy9XNZGAAAAAAAAAABCI7CRyDwKeiTz9s+TYZuGyV/X/3Ja55vdV/pV7ycNizQUTw9Pl7URAAAAAAAAAICIENhIBBYfWSwD1g2Qo1eOioeHhwQEBzitr5yrsnxW/TOpW6CuWQ8AAAAAAAAAQHxFYCOBW3hooTRb1Oy/Bbb/fq2Zr6aZcuqFvC8Q0AAAAAAAAAAAuAUCGwnc4A2Dw11eMENBWd1ydZy3BwAAAAAAAACAp0EhhQTu+LXj4S4/538uztsCAAAAAAAAAMDTIrCRwBXOVFg8xHmaKb1fJGMRl7UJAAAAAAAAAIAnRWAjgRtQY4DYxGYPbuhPva/LAQAAAAAAAABwNwQ2ErjXir0mPzX7SUplLSXJvJKZn4ubLZYmxZq4umkAAAAAAAAAAEQbxcMTSXCjcZHGcvnyZcmSJYt4ehLPAgAAAAAAAAC4J0a4AQAAAAAAAACA2yCwAQAAAAAAAAAA3AaBDQAAAAAAAAAA4DYIbAAAAAAAAAAAALdBYAMAAAAAAAAAALgNAhsAAAAAAAAAAMBtENgAAAAAAAAAAABug8AGAAAAAAAAAABwGwQ2AAAAAAAAAACA2yCwAQAAAAD/b9KkSZI3b15Jnjy5VKxYUXbs2BHp9gsXLpSiRYua7UuVKiXLly+Ps7YCAAAAiRWBDQAAAAAQkQULFkj37t1lwIABsmfPHildurTUrVtXLl++HO72W7ZskbfeekvatGkje/fulcaNG5vbn3/+GedtBwAAABITAhsAAAAAICJjxoyRdu3aSevWraV48eIydepUSZkypXz77bfhbj9+/Hh5+eWXpWfPnlKsWDEZNGiQlCtXTr766qs4bzsAAACQmCRxdQMSA5vNZn76+/u7rA3BwcFy+/ZtkyLv6Uk8KzGiD0DRD0AfAH0A8aEfWJ+Lrc/J8cGjR49k9+7d0qdPH/syPTe1a9eWrVu3hvsYXa4ZHo40w2Pp0qXhbv/w4UNzs9y6dcvl3xNUwL0Alz4/gMTJ1e998V4A780AXMTfde/P0fmeQGAjDuiXRpUrVy5XNwUAAACIV5+TfXx8JD64evWqBAUFSdasWZ2W6/2jR4+G+5iLFy+Gu70uD8+wYcNk4MCBYZbzPQFAYuTTNn68/wMAQokHn8+j8j2BwEYcyJEjh5w9e1bSpEkjHh4eLot26RcmbUfatGld0ga4Fn0Ain4A+gDoA4gP/UCvwNIvK/o5OTHRbBDHDA/NnLl+/bpkzJjRZd8TAHd9HwEAhI/3Z7iz6HxPILARBzSF/ZlnnpH4QN/QeFNL3OgDUPQD0AdAH4Cr+0F8ydSwZMqUSby8vOTSpUtOy/V+tmzZwn2MLo/O9smSJTM3R+nSpXvqtgOuxP8nABA/8f4MdxXV7wlMrAwAAAAg0fP29hZfX19ZvXq1U0aF3q9UqVK4j9HljturVatWRbg9AAAAgJhBxgYAAAAAiJhpovz8/KR8+fJSoUIFGTdunNy9e1dat25t1rds2VJy5sxpamWoLl26SI0aNWT06NHSoEEDmT9/vuzatUu+/vprFx8JAAAAkLAR2EgkNOV9wIABYVLfkXjQB6DoB6APgD4ART8IX/PmzeXKlSvSv39/UwC8TJkysmLFCnuB8DNnzphpZi2VK1eWefPmSb9+/aRv375SqFAhWbp0qZQsWdKFRwHEDd5HACB+4v0ZiYWHTStyAAAAAAAAAAAAuAFqbAAAAAAAAAAAALdBYAMAAAAAAAAAALgNAhsAAAAAAAAAAMBtENgAAAAAAAAAAABug8BGAjJp0iTJmzevJE+eXCpWrCg7duyIdPuFCxdK0aJFzfalSpWS5cuXx1lb4fo+MH36dKlWrZqkT5/e3GrXrv3YPoOE9z5gmT9/vnh4eEjjxo1jvY2If/3g5s2b0qlTJ8mePbskS5ZMChcuzP8JiawPjBs3TooUKSIpUqSQXLlySbdu3eTBgwdx1l7ErA0bNsirr74qOXLkMO/tS5cufexj1q1bJ+XKlTPvAQULFpRZs2bFSVsBxI2LFy/Khx9+KPnz5zd/5/per+8Tq1evlvhG33/SpUvn6mYAQIxp1apVgv2u/cILL0jXrl1d3QwkUgQ2EogFCxZI9+7dZcCAAbJnzx4pXbq01K1bVy5fvhzu9lu2bJG33npL2rRpI3v37jVvsHr7888/47ztcE0f0AEM7QNr166VrVu3mi83derUkfPnz8d52+GaPmD5559/pEePHibQhcTXDx49eiQvvfSS6QeLFi2SY8eOmcBnzpw547ztcE0fmDdvnvTu3dtsf+TIEfnmm2/MPvr27RvnbUfMuHv3rnndNcAVFadOnZIGDRrIiy++KPv27TNfTtu2bSsrV66M9bYCiH36f7yvr6+sWbNGRo4cKQcPHpQVK1aYv3m9sOFJ6OeH8AQEBDxlawEAMS289+ygoCAJDg52SXuAGGNDglChQgVbp06d7PeDgoJsOXLksA0bNizc7Zs1a2Zr0KCB07KKFSva3n///VhvK+JHHwgtMDDQliZNGtvs2bNjsZWIb31AX/fKlSvbZsyYYfPz87M1atQojlqL+NIPpkyZYsufP7/t0aNHcdhKxKc+oNvWrFnTaVn37t1tVapUifW2Ivbpx/0lS5ZEus0nn3xiK1GihNOy5s2b2+rWrRvLrQMQF+rVq2fLmTOn7c6dO2HW3bhxw/w8ffq0rWHDhrZUqVKZ7wRvvPGG7eLFi/btBgwYYCtdurRt+vTptrx589o8PDzs7zGTJ0+2vfrqq7aUKVOa7dTSpUttZcuWtSVLlsyWL18+2+eff24LCAhwet727dvbsmTJYrbR96BffvnFtnbtWrNPx5u1TwBwV47ftWvUqGH78MMPbT179rSlT5/eljVr1jDvcxG9R1oWLVpkK168uM3b29uWJ08e26hRo5wer8u++OILW4sWLcx7uj7/zJkzbT4+Praff/7ZVqxYMZuXl5ft1KlTtgcPHtg+/vhj831B38f1u4S+FzvatGmTaXeKFCls6dKls9WpU8d2/fp1s9/Q79m6TyCukLGRQCKvu3fvNlMJWTw9Pc19vRI/PLrccXulV3NGtD0SXh8I7d69e+YKqwwZMsRiSxHf+sAXX3whWbJkMdlbSJz9YNmyZVKpUiVzxWbWrFmlZMmSMnToUHMFDxJHH6hcubJ5jDVd1d9//22mIqtfv36ctRuuxedCIOG6fv26yc7Q/+dTpUoVZr1O+aRX7DZq1Mhsu379elm1apX5v6B58+ZO2/7111/y008/yeLFi012l+Xzzz+XJk2amEyQ9957TzZu3CgtW7aULl26yOHDh2XatGlmeqkhQ4aY7fX56tWrJ5s3b5a5c+eabb788kvx8vIy/yfp9Ihp06aVCxcumJtmFgNAQjJ79mzznrx9+3YZMWKE+V6u772Pe49U+rm9WbNm8uabb5r3XX0P/uyzz8JMIzpq1CiTwauztOh6a9xn+PDhMmPGDDl06JAZC+jcubP5zKfTUx84cEDeeOMNefnll+XEiRPmMfp+X6tWLSlevLjZbtOmTWYqQ/2+OH78ePNdsl27dvb3bJ0NBIgrSeLsmRBrrl69at5QdEDKkd4/evRohHOshre9Lkfi6AOh9erVy8zFHXpgAwm3D+gHEp1yxvGLKRJfP9CBC52a4p133jGD2Tpo0bFjRxPo1KmJkPD7wNtvv20eV7VqVc3klcDAQOnQoQNTUSUiEX0u9Pf3l/v375vaKwDck/6/ru/tWlsxIlpnQwfHdFo6a0Dqu+++kxIlSsjOnTvlueeeswfPdXnmzJnD/D/SunVr+30NbugUh35+fua+1vUYNGiQfPLJJ+azxR9//GGC6Tr9odb1srax+Pj4mPpA2bJli+GzAQDxw7PPPmv/rlWoUCH56quvzHuxThH8uPfIMWPGmECDFazQbTT4oVMNai0PS82aNeXjjz+239egs37Hmzx5sgl4qDNnzsjMmTPNTx0PUhpM1oC4LtcL3jTwUr58efM4i/7/YPH29paUKVPyng2XIGMDgIn+a3R+yZIlptAsEr7bt29LixYtTC2FTJkyubo5cCG9Ikiv1Pn666/N/Nt6deann34qU6dOdXXTEEe05pJ+adEvK1qTQ6/E/d///mcGoQAA7i1ktqjI6eCZBjQcr7LVK3M1m0PXWfLkyRMmqKF0wMvR/v37zdXHqVOntt+sq3n1amG9qOaZZ56xD9gBQGIMbDjKnj27vR7e494j9X25SpUqTsv0vmZYOGbdh35vtoIQjs+tQW19jD6X43u2Zu+dPHnS3h4NpADxERkbCYAOSmpK2qVLl5yW6/2IIqa6PDrbI+H1Acf0RA1s6FUBof9zRcLtA/ohRQtJagqpxSocliRJElNAukCBAnHQcrj6vUA/RCdNmtSe2qyKFStmruDWKzP1wy8Sdh/Qq7000KnFolWpUqVM8en27dubIJdOZYWELaLPhToVDNkagHvTK4E1+yGqWdyRCW8qq/CW37lzRwYOHCivvfZamG31IireVwAkdvr9y5G+T1vfx2PqPTK892zdtz6X4/u1fnfQ6a0cvw8qDXDEZHuA2MA31QRAB530KltNW7PoG6Le17nuwqPLHbdXOp9fRNsj4fUBpSmFekWuphmGF81Hwu0DOh2BXp2hV19Yt4YNG8qLL75ofmdezMTzXqBX9+g0FdYHaXX8+HET8CCokTj6gF49Gzp4YX2xicqVvnB/fC4EEi6tn6c1cyZNmmSC1qHdvHnTXNBw9uxZc7PotCa6TjM3oqtcuXLmIpmCBQuGuen/N3ox1blz58znjYj+L6PWF4DE6nHvkfqerfU3HOl9zboIHZx4nLJly5r3W80WCf1+bV0Upe0J/TnREe/ZcCUCGwlE9+7dzZQyWoBI09I++OAD88HVmutUi7f16dPHvr0WctPB7NGjR5urd7TY0K5du0zRICSOPqAFo/Qq3W+//Vby5s1rrs7Wm0bskfD7gF4tp0WiHW863UCaNGnM7wxoJ573Al2vxUL1/wX98KxTEOm0RFpkFImjD2jm1pQpU8yUhDq/ug5o6/8Pujy6X44QP+j/5VbQWunrqr/r/MlKX3/tBxatqaL1dnT+e/1cqNOS/fjjj9KtWzeXHQOAmKNBDR10qlChgin+rdOV6P8PEyZMMAFMrbGn2Xpab0unJNS53fU9okaNGk908VP//v1NLQ7N2tDitPpc+n9Mv379zHrdb/Xq1aVp06bm/xx9j/rtt9/M91Ol3030fUwH0rQGlAbgASCxeNx7pNbN0PdHvUhVv7/pZ36t0aG1MaJLgyH63q/v+TodrT6X/h8wbNgw873Q+tyo9Za0DqMWF9fPivrdQd+frfdsLYKuM0LoMscL5oBYZ0OCMXHiRFvu3Llt3t7etgoVKti2bdtmX1ejRg2bn5+f0/Y//vijrXDhwmb7EiVK2P73v/+5oNVwVR/IkyePXoYb5jZgwAAXtR6ueB9wpOsaNWoURy1FfOoHW7ZssVWsWNGWLFkyW/78+W1DhgyxBQYGuqDlcEUfCAgIsH3++ee2AgUK2JInT27LlSuXrWPHjrYbN264qPV4WmvXrg33/3jrddef2g9CP6ZMmTKmz+j7wMyZM13UegCx4d9//7V16tTJfAfQv/OcOXPaGjZsaP721enTp839VKlS2dKkSWN74403bBcvXrQ/Xr8jlC5dOsx+9b1lyZIlYZavWLHCVrlyZVuKFClsadOmNf8Xff311/b1165ds7Vu3dqWMWNG839PyZIlbb/++qt9fYcOHcw6vp8ASAgcv2vrZ7AuXbo4rdd1jp/PH/ceuWjRIlvx4sVtSZMmNZ/5R44c6bQ/fa8fO3as0zL9bOfj4xOmbY8ePbL179/fljdvXrO/7Nmz25o0aWI7cOCAfZt169aZ93T9vpguXTpb3bp17d8Vjh07Znv++efN+72+Z586deqpzxcQVR76T+yHTwAAAAAAAAAAAJ4eU1EBAAAAAAAAAAC3QWADAAAAAAAAAAC4DQIbAAAAAAAAAADAbRDYAAAAAAAAAAAAboPABgAAAAAAAAAAcBsENgAAAAAAcDOtWrWSxo0bu7oZAIBQeH8G4gaBDQAAAAAAAAAA4DYIbAAAEEPWrVsnHh4ecvPmTVc3BQAAJGJjxoyRUqVKSapUqSRXrlzSsWNHuXPnjn39rFmzJF26dLJy5UopVqyYpE6dWl5++WW5cOGCfZvAwED56KOPzHYZM2aUXr16iZ+fn9NVyHnz5pVx48Y5PXeZMmXk888/j3Jb1PTp0826lClTSpMmTcxj9Hkd/fzzz1KuXDlJnjy55M+fXwYOHGjaCADuhPdnIOYQ2AAAxFi6rQ7qh7799ddf4g7C++AHAADgjjw9PWXChAly6NAhmT17tqxZs0Y++eQTp23u3bsno0aNkjlz5siGDRvkzJkz0qNHD/v64cOHy/fffy8zZ86UzZs3i7+/vyxdujTG26L77tChg3Tp0kX27dsnL730kgwZMsRpHxs3bpSWLVuabQ4fPizTpk0zg3+htwOA+I73ZyAG2QAAiAF+fn62l19+2XbhwgWnW2BgYJhtHz58aItv8uTJYxs7duxT7WPt2rU2/a/1xo0bMdYuAACAiD57NWrUKErbLly40JYxY0b7/ZkzZ5rPLH/99Zd92aRJk2xZs2a139ffR44cab+vn+ly587t9JzhfX4qXbq0bcCAAVFuS/PmzW0NGjRw2uadd96x+fj42O/XqlXLNnToUKdt5syZY8uePXuUjh8A4hLvz7w/I26QsQEAiDHJkiWTbNmyOd28vLzkhRdekM6dO0vXrl0lU6ZMUrdu3Wil4f76669SpEgRk/76+uuvmytY9IoSzbJInz69ScMNCgqyP+7hw4fmipacOXOafVesWNFMExUdmm0yY8YMk26rz1uoUCFZtmyZ0zbLly+XwoULS4oUKeTFF1+Uf/75J8x+Nm3aJNWqVTPb6DFqW+/evWvWfffddya1+MSJE/bt9RwULVrUHCMAAMCT+OOPP6RWrVrms1CaNGmkRYsWcu3aNafPF/r5pkCBAvb72bNnl8uXL5vfb926JZcuXZIKFSrY1+tnOl9f3xhvy7Fjx5yeR4W+v3//fvniiy/M5ybr1q5dOzM1C5+ZALgT3p+BmENgAwAQJzQQ4e3tbdJZp06dGq00XN1m/vz5smLFChOg0GCDBhX0pum5mu66aNEi+2M0iLJ161bzmAMHDsgbb7xh5iV1DCBEhc4N2qxZM7OP+vXryzvvvCPXr183686ePSuvvfaavPrqqyYtt23bttK7d2+nx588edI8b9OmTc0+FixYYAId2j6lKbvWfnUO0v/9738mmKJpxfphFgAAILr0QotXXnlFnn32Wfnpp59k9+7dMmnSJLPu0aNH9u2SJk0a5qIOm00vFI46/SwX+jEBAQHRbsvj6IUv+rlMP3NZt4MHD5rPdjqnOwC4A96fgZiVJIb3BwBIxDSzQq/QsNSrV08WLlxofteMhxEjRjhtrxkcFs2+GDx4sJnDc/LkyU4fvqZMmWK/YkUzNjSYoVep6HMVL17cZEusXbtWmjdvbuYf1blG9WeOHDnMYzR7Q4Miunzo0KHRqhvy1ltvmd/1cRpg2bFjhwlWWG0aPXq0Wa8ZJfoBTuc7tQwbNswELazj1HOg+6hRo4Z5vH7Q06CMfpjUTI7FixebYm5PcrUNAACA0sGp4OBg8xlFB7bUjz/+GK19+Pj4SNasWWXnzp1SvXp1s0yzY/fs2WOKz1oyZ87sVNBW53k/depUtNqin6H0eRyFvq9FafXK4YIFC0brOAAgPuH9GYhZBDYAADFGAww6YG/RaaAs4Q3Wa+qrDv4fPXrUfNDSrIUHDx6YLA0rYyF0Gq5+iNMgiGMARZdZqbkaXNAPdjpFlCOdnipjxozROh4NODgeS9q0ae3Pc+TIETPFlaNKlSqFScvVTA3NwLDoVTP6AVI/VBYrVsxMpfXNN9+Y6bkqV64cJusDAAAgIjoliV4d60in/dQLQyZOnGgySx2zZaPjww8/NJ/TdLBKp8nU/d24ccNcOWypWbOmmTpUn0enD+3fv7+ZEsWij31cW/R5dHBOpyjVbTSD97fffnN6Ht2vXlmcO3duc5GLDsLp56w///zTXBgDAPEN78+8PyP2MRUVACDG6OC/fkCybjoXqOO6mErDDW+ZBgusVFj9wKb7c0yH1UDE+PHjo3U8kT1PVGhb3n//fad26Ic8Tct1DNZs2LDBtFmvqLHqbwAAADyOTtFZtmxZp5tmtuoglGaRlixZ0lxgoQNg0dWrVy+TuapTZ+rFG3pRiV6I4Ti1SJ8+fUwmqn6ma9CggTRu3NjpM07p0qUf25YqVaqYwTTdTrfXLNtu3bo5PY8+r2YG//777/Lcc8/J888/L2PHjpU8efI88bkDgNjE+zPvz4h9HlpBPA6eBwCQwOm0TTdv3pSlS5eGWafFwzUtdty4cfZlGszQD2OaoWGlvuoVHZ999pm52kSvKtErTHQaJ92vRadq0udwvPrF8bmPHz9uUmY1WKBFu6NKs0D0uaxpozSIsWTJEvMB0KJt0mPQ5+vbt68pJq5Xojh+ePzyyy/t7ddpqHTKLM1MiciWLVvMB07dl35A1Q+8Wm8EAAAgPtGLOzTbVOuPDRo0KFafSwvPakbvxo0bY/V5ACAh4P0ZiRUZGwAAl3BMff3777/N1StPkoYbmk5BpQEFvXpFa1bolE9aF0OvPtHi3DFFa4Fo5kXPnj3NnKLz5s0zgRhHGqjQwIUWC9dAjG7/888/24uH3759W1q0aGHqa2g9Er1KRguMOxZCBwAAcIXTp0/L9OnTzUUjOtXnBx98YD5Xvf322zH+XKNGjTJZrX/99Zf5bKgXefj5+cX48wBAQsD7MxCCwAYAwCWikvr6pLRIuAY2Pv74Y5O9oVkXWuRM5/2MKbovzTrRLBE9Fg3KhC5MrtNsrV+/3nzg1OwRzcbQOUitouZdunQxU3RZjytVqpT5XaevOn/+fIy1FQAAILo0o1Yv2tCpRXQ6Eh080yxUvSo4pulFKC+99JL5LKSfqSZMmCBt27aN8ecBgISA92cgBFNRAQAAAAAAAAAAt0HGBgAAAAAAAAAAcBsENgAAAAAAAAAAgNsgsAEAAAAAAAAAANwGgQ0AAAAAAAAAAOA2CGwAAAAAAAAAAAC3QWADAAAAAAAAAAC4DQIbAAAAAAAAAADAbRDYAAAAAAAAAAAAboPABgAAAAAAAAAAcBsENgAAAAAAAAAAgNsgsAEAAAAAAAAAANwGgQ0AAAAAAAAAAOA2CGwAAAAAAAAAAAC3QWADAAAAAAAAAAC4DQIbAAAAAAAAAADAbRDYAAAAAAAAAAAAboPABgAAAAAAAAAAcBsENgAglnh4eMjnn38e4/tdt26d2bf+dDRnzhwpWrSoJE2aVNKlS2dfPnLkSMmfP794eXlJmTJlJLELDg6WkiVLypAhQ1zdFCQCzz//vHzyySeubgYAAAAAAAkKgQ0AcW7WrFlmYN66JUmSRHLmzCmtWrWS8+fPS2Lyzz//OJ0LDUpkypRJKleuLH379pUzZ85EaT9Hjx41569AgQIyffp0+frrr83y33//3QyqVqlSRWbOnClDhw6VxO6HH36Qs2fPSufOncOsO3nypLz//vsmEJQ8eXJJmzatOXfjx4+X+/fvi7s5fPiwCa5pP4utv+Ndu3ZJYhfZee7Vq5dMmjRJLl686JK2AQAAAACQECVxdQMAJF5ffPGF5MuXTx48eCDbtm0zA6WbNm2SP//80wwqJyZvvfWW1K9f32QT3LhxQ3bu3Cnjxo0zA+rffPONvPnmm/Ztq1evbgbZvb297cs0e0Mfq9sXLFjQvnzNmjXi6elp9uG4fWKmGSx6Pn18fJyW/+9//5M33nhDkiVLJi1btjRZHY8ePTJ9smfPnnLo0CF7wMidBtwHDhwoL7zwguTNm9fVzUmwIjvPjRo1MgGyyZMnm/c8AAAAAADw9AhsAHCZevXqSfny5c3vbdu2NZkKw4cPl2XLlkmzZs0kvrt7966kSpUqRvZVrlw5effdd52WnT59WurUqSN+fn5SrFgxKV26tFmugYrQgZ/Lly+bn45TUFnLU6RIEaNBjXv37knKlCnFHe3du1f2798vo0ePdlp+6tQpE+zIkyePCQZlz57dvq5Tp07y119/mcDH07LZbCaQp69JaLpcXyd9fZFwzrM+z+uvvy7fffedCX5olgsAAAAAAHg6jJ4AiDeqVatmnw4o9DRLOjCYIUMGM6CvwRANflhu3rxp6kdMmDDBvuzq1atmQDFjxoxmkNPywQcfSLZs2ez3N27caK7Sz507t7lSP1euXNKtW7cw0w7pNE+pU6c2bdPMijRp0sg777xj1j18+NA8JnPmzGZ5w4YN5dy5c099PnSQXbNYNGtgxIgREdbY0CvEBwwYYH7XNli1PfSnTj+lARhrqivdn2Xu3Lni6+trBn/13OrAvk7R5EivQNfMhd27d5tMEQ1o6BRZ1nHr82qGiHXudNorXe5In1enfVq6dKnZl25bokQJWbFiRZhj1qnI2rRpIzly5DDbaUaPvmZ6Dhxf765du5rn0230+TUgphkrj6Nt0EFtPRZHen7v3LljMlscgxoWfY4uXbrY7wcGBsqgQYPM1F/aBn0N9LyEPnZd/sorr8jKlStNv9VzPW3aNPtrOH/+fOnXr5+Zik3Prb+/v3nc9u3b5eWXXzZZJbq8Ro0asnnz5midL32ttW+rF1980d4HQtdmiUnW34m2q3HjxuZ37ZM9evSQoKAgp22tDKNSpUqZv2vdTo/ZcWqrhHKeX3rpJROo3LdvX4yfcwAAAAAAEiMyNgDEG9b89OnTp7cv0+l/tMaBDkj27t3bZEj8+OOPZtD0p59+kiZNmpgsBR0w37Bhg3z00UfmcTp9kA4uXr9+3UwTowPpViDDCqCohQsXmgwEHaTUIMiOHTtk4sSJJjCh6xzpIGvdunWlatWqMmrUKHvWgmabaJDg7bffNrUx9Ir/Bg0axMg5qVSpkhnUXbVqVYTb6JRVejX4kiVLZMqUKWYw+dlnnzWD8Tp1kh7TjBkzzLbaPqWFsz/77DOTGaPtv3LlijluHfDXrAbHzI9r166Z7BoNfGhWSdasWc2gtAZw9Dy3b9/eZJQcPHhQxo4dK8ePHzcBBEe63eLFi6Vjx44m+KNBqKZNm5oaInre1b///isVKlQwgQvdpxZC1wHlRYsWmddIAxL6UwefdbnWwtCA1JYtW6RPnz5y4cIFcy4io9tqX9FaJo5++eUXU1fDOj+Po+ds9uzZJuD28ccfmwHyYcOGyZEjR8zr4OjYsWNmqjFtb7t27aRIkSL2dTpor8elA/86WK+/a//R861BJw0caYBOA1Q1a9Y0/VfPUVTOl76W+veg51qDAfoaKetnbNEAhv6dVKxY0fyd/PHHHyZDRvux/p1ZNFCgQQE9Vj2f+velx6fT0jlmciWE86zPoTRoUrZs2Vg9/wAAAAAAJAo2AIhjM2fO1BQK2x9//GG7cuWK7ezZs7ZFixbZMmfObEuWLJm5b6lVq5atVKlStgcPHtiXBQcH2ypXrmwrVKiQfVmnTp1sWbNmtd/v3r27rXr16rYsWbLYpkyZYpZdu3bN5uHhYRs/frx9u3v37oVp37Bhw8x2p0+fti/z8/Mzbe7du7fTtvv27TPLO3bs6LT87bffNssHDBgQ6bk4deqU2W7kyJERbtOoUSOzza1bt8z9tWvXmvv606LPo8v0fDrSdqdKlcpp2T///GPz8vKyDRkyxGn5wYMHbUmSJHFaXqNGDbPfqVOnOm07Z84cm6enp23jxo1Oy3U73X7z5s32ZXrf29vb9tdff9mX7d+/3yyfOHGifVnLli3NPnfu3BnmHOhrrgYNGmSO5/jx407r9XXRYzpz5owtMs8884ytadOmTsv0vGpb9DxHhfWat23b1ml5jx49zPI1a9bYl+XJk8csW7FihdO21muYP39+pz6ox6n9um7duvZjVrpNvnz5bC+99FK0ztfChQvD9JWY/jt2fH7r7+SLL75w2rZs2bI2X19f+309R7rdRx99FGHbE9p51r+BDz74IML1AAAAAAAg6piKCoDL1K5d20w/o1MK6RXZmo2hU0w988wzZr1mW+hV1ZpVcPv2bTO9lN40g0CvCD9x4oS5clppFsalS5fMVdtKr7jWK6l1uf5uZQ3oOLtjxobjHPw6ZZPuX6/a1+00cyE0xyvO1fLly81PK1PEolMlxRTNwFB6DmKCZk5oxoWeV+uc6k2n6CpUqJCsXbvWaXudeqd169ZOyzSbRa9I16vXHfehV7ur0PvQ11qv2LdoRokWVP7777/NfW2PZnm8+uqr9qv1HVl1CfR59fXTrB7H59X9a6aAZu1ERvuOY0aQsqYl0kySqLBe8+7duzst14wCFboWh05bpP01PFo/xbEP6lRF2q81+0fbah2f9s1atWqZ49NzFdXz5SodOnRwuq+vmfVaK8220jZaU6iF1/aEdp6tPgsAAAAAAJ4eU1EBcJlJkyZJ4cKF5datW/Ltt9+awUQdRLdowWYNMOiUSXoLjxbH1mmqrGCFBjE0MKJBicGDB5vAiU6HY63TwXSrCLfSqZD69+9vAio3btxw2re2y1GSJEnsQReLzpuvU9g4Dtorx2lwnpbWfojOwPvj6ICunlcNYoQn9DRNen5DFx/Xfeh0QHp+w2MVM7folFHhDfRa51ynwtIAg04T9bi2HzhwIMrPGx7HmitK+0R0AkfWa65TfTnSwJBO4aXrQw+4RyT0Oj0+ayA+ItovtbZDVM5XdGhdmdB93rEeTVRZ9TIieq2V1qrRehVa2yWxnGftd64OOAEAAAAAkFAQ2ADgMjpvvXUVtNbM0NoVegW1Zl1oloJVDFrnxY/oSmxr0FMHSXXwUoMjWkhYBxG1PoUOsGrRZx0E1cCGZmPoYKnSK/y1qK9mhvTq1ctkH2jWiGaBaBHk0MWoNehiPTYu/fnnn5IlSxb7APzT0uPSAdbffvvNFF2PKEPE4nilu+M+tOjzmDFjwn0OzcJxFN7zhBdkiErb9TXTIuXh0UBZZLSeR+gAlp5X7T96nqMjqoPU4Z2/iNZZfW7kyJFSpkyZcB+jr4/22Zi2YMGCMJk50X19Inutn1RCOc9aoyNTpkwxtj8AAAAAABIzAhsA4gUdDNWiwC+++KJ89dVXplC4FnO2Mgh0qqHH0awNDWxogEMHKzXDQbMzfHx8ZMWKFbJnzx4ZOHCgfXstdq2FrrU4ccuWLe3LIyvUHVqePHnMIKlege6YpWFNifW0tm7davatRbtjimaX6IC1nqfHBQIi28f+/fvNtD0xcRW6BqA0wPC44II+r2awRKU/hEeDV6dOnQqz/JVXXjGF1vV8a0AsKq+5XvXvWCBap0LTwWtd/6SszB89F5EdY1TPV3ReGw0eRqfvPw09zpUrV5rAQURZGwnpPGuwVLM/YrtwOwAAAAAAiQU1NgDEGy+88ILJ4hg3bpw8ePDAZCnosmnTpsmFCxfCbK/TF4UObPzzzz/mynNrairNsNAsDc0sCAgIcKqvYV1Z7nhVuv4+fvz4KLe5Xr165ueECROclusxPC3NMtHMEZ0GqmfPnhJTXnvtNXPsGuQJfUW+3teaA4+j9Tl0sHb69OnhTmmktQqiQ18nzdr55ZdfZNeuXWHWW+3U59Xggw6Kh6aD3YGBgZE+jwYtdJD64cOHTss1A0Szddq2bWsGzkPT4JLVL+rXrx/ua2xlrzRo0ECelK+vrxl01+nTrCnIwuvzUT1fekzWuXmc7Nmzm0F+x1tsadq0qWmjY6AxdNsT0nnevXu3+anvRQAAAAAA4OmRsQEgXtEB/DfeeENmzZplChBrHQ6dokqnPWrXrp3J4tCBZx3cPnfunMkasFhBC82WGDp0qH25FhHXaZd0KqnnnnvO6ep9HdzUqa50kF6vzNaixqGnKoqMZoa89dZbMnnyZDMnvw5crl692tQHiQ7NJpk7d665Ql0HR3fu3GkvsDxnzhxTbDum6DFr/ZE+ffqYQJAO3Gp2i2YyLFmyRNq3b2/OSWRatGghP/74o3mNtFB4lSpVzNReR48eNcs18BBeseXI6Gv2+++/S40aNUwb9Op2DWhpwXAt/K51FbR/aD0UzbDQoI8OUGsQRbNvFi1aZI4nsul+GjVqJIMGDZL169dLnTp1nM7JvHnzpHnz5uZ5NYNH6yroVfZbtmwxbdDnU5oFpLUZNMNDXytt744dO0zmj55LzTp6UjqQPmPGDBMwK1GihJkaSmucaP/U86x9VAfZo3q+tH9qEGv48OGmf+rfgBZ416ChK+k50j6kAUHNyHj55ZdN39fp4nRd586dE9R51kwYrTNTtmzZGDuHAAAAAAAkajYAiGMzZ87Uy5xtO3fuDLMuKCjIVqBAAXMLDAw0y06ePGlr2bKlLVu2bLakSZPacubMaXvllVdsixYtCvP4LFmymH1funTJvmzTpk1mWbVq1cJsf/jwYVvt2rVtqVOntmXKlMnWrl072/79+8322k6Ln5+fLVWqVOEez/37920fffSRLWPGjGabV1991Xb27FmzjwEDBkR6Lk6dOmW2s25JkiSxZciQwVaxYkVbnz59bKdPnw7zmLVr15pt9adFn0eXXblyxWnbyNr9008/2apWrWrW661o0aK2Tp062Y4dO2bfpkaNGrYSJUqE+/hHjx7Zhg8fbtYnS5bMlj59epuvr69t4MCBtlu3btm303bpfkPLkyePaZ8jPV59rTNnzmz2mT9/fvPYhw8f2re5ffu2OTcFCxa0eXt7m9etcuXKtlGjRpk2Pc6zzz5ra9OmTbjrjh8/bvpA3rx5zb7TpEljq1Klim3ixIm2Bw8e2LcLCAgwx5kvXz7TJ3PlymXa5LiNdYwNGjSI8DVcuHBhuO3Yu3ev7bXXXjN9Ss+D7qdZs2a21atXR/t8TZ8+3Sz38vIK029i+u84ov5m9U9H+vc9cuRI0+/0XOsx1KtXz7Z79+4EdZ71PS179uy2fv36ReGsAgAAAACAqPDQf1wdXAEAIK5oBkynTp3kzJkz5mp7IDYtXbpU3n77bTOdmU73BQAAAAAAnh41NgAAico777xjpgXSac6A2KbTU+nUWgQ1AAAAAACIOWRsAAAAAAAAAAAAt0HGBgAAAAAAAAAAcBsENgAAAAAAAAAAgNsgsAEAAAAAAAAAANwGgQ0AAAAAAAAAAOA2CGwAAAAAAAAAAAC3kcTVDUgMgoOD5d9//5U0adKIh4eHq5sDAAAAuJTNZpPbt29Ljhw5xNOTa60AAAAARA+BjTigQY1cuXK5uhkAAABAvHL27Fl55plnXN0MAAAAAG6GwEYc0EwN64tb2rRpXZY1cuXKFcmcOTNXxSVS9AEo+gHoA6APID70A39/f3Phj/U5GQAAAACig8BGHLCmn9KghisDGw8ePDDPzyBG4kQfgKIfgD4A+gDiUz9gmlYAAAAAT4JvswAAAAAAAAAAwG0Q2AAAAAAAAAAAAG6DwAYAAAAAAAAAAHAbBDYAAAAAAAAAAIDbILABAAAAAAAAAADcBoENAAAAAAAAAADgNghsAAAAAAAAAAAAt0FgAwAAAAAAAAAAuA0CGwAAAAAAAAAAwG0Q2AAAAAAAAAAAAG6DwAYAAAAAAAAAAHAbbhfYmDRpkuTNm1eSJ08uFStWlB07dkS6/cKFC6Vo0aJm+1KlSsny5cud1ttsNunfv79kz55dUqRIIbVr15YTJ044bXP9+nV55513JG3atJIuXTpp06aN3LlzJ1aODwAAAAAAAAAAJJDAxoIFC6R79+4yYMAA2bNnj5QuXVrq1q0rly9fDnf7LVu2yFtvvWUCEXv37pXGjRub259//mnfZsSIETJhwgSZOnWqbN++XVKlSmX2+eDBA/s2GtQ4dOiQrFq1Sn799VfZsGGDtG/fPk6OGQAAAAAAAAAA/MfDpikLbkIzNJ577jn56quvzP3g4GDJlSuXfPjhh9K7d+8w2zdv3lzu3r1rghGW559/XsqUKWMCGXroOXLkkI8//lh69Ohh1t+6dUuyZs0qs2bNkjfffFOOHDkixYsXl507d0r58uXNNitWrJD69evLuXPnzOMfx9/fX3x8fMy+NevDFfRcaQAoS5Ys4unpVvEsxBD6ABT9APQB0AcQH/pBfPh8DAAAAMB9JRE38ejRI9m9e7f06dPHvky/hOnUUVu3bg33MbpcMzwcaTbG0qVLze+nTp2Sixcvmn1Y9AuWBlD0sRrY0J86/ZQV1FC6vT63Zng0adIkWsegt9B0X0mS/PdShLeNxcPDQ5ImTfpE2wYEBJjtw/vyGt62EcW8orOt8vb2fqJtAwMDzZfumNhW26vtjs1tg4KCzC0mttX+YL1OMbWtHofjsURnv/o4PRcR8fLyMrf4sq32Me1rMbGt499nbG37uL/lmHyP0PNovRfpOYiNv3veI+L3e4T1f0F4/x886X7jw9897xFRf4+wji0q2/IekXDfI6z/D/RnTH/mCL1teH+fkfU9AAAAAEgwgY2rV6+aL0+aTeFI7x89ejTcx2jQIrztdbm13loW2TZ6JVvoL2oZMmSwbxPaw4cPzc3xijQ1atQoSZYsWZjtCxYsaKa7cpweK6LBjjx58kirVq3s98eOHSv37t0Ld1utG2JNmaVfKGfOnGm+VFpfih1lzpxZOnbsaL8/bdo0uXLlSrj71UBPly5d7Pe/+eYbuXDhQrjbpkyZUnr27Gm/P2fOHDl9+nSEX9j79u1rv//DDz/IX3/9JRHRKcksixYtMtk1EdGAmDWAsWzZMtm/f3+E22r2jk5Jpn777TfZtWtXhNvqedDzoXSqsoiCbOqDDz6w96X169ebW0Tatm0rOXPmtE+p9scff0S4rZ+fn6k7ozSzSNscHh0IqlOnjr0Neg5+/vnnCPf7+uuvS4kSJczvOhWbnuOINGrUyGRCqePHj5vXLiL16tWTChUqmN//+ecfmT17doTbahCxSpUq5vfz58/LjBkzIty2Ro0a8sILL5jf9QrUKVOmRLhtpUqVzLlQN2/elPHjx0e4rQY1GzRoYH7XDDD9O46ITo+n091ZAzbDhg2LcNtixYpJs2bN7PeHDBkS4bYx+R6h/UCPQ/u4Zpw5Tqun2XB6PsLDe0TCeY/QWlNWHwj9/4FO31i4cGHzO+8RCfc9omXLlua9QD8bRPVzhOI9ImG9R1j/H+h+8+fP/9jPETH9HuH4WRkAAAAAEmxgw53oQMXAgQPDLNcvj+FdTaqBD8c6IVqYPKKrTm/fvh1m2/v37z92Wx280O10ICW8wIYWV3fcrz5W2xsevdIzqtta0xxEZVsNGDluq+clom1VdLe1BiR0yoPIttWBGGt9VLa1rjjUwZ7IttXgnCUq21pXs964cSPSba9du2YGfh63rQ5gWH1Cr6C8fv16pPvV9dY5js622p7IttU2Psm2ek4i21bP6ZNs+7jXWNdb2+rgX1S31X4R2bah/+6js+3TvEdoP7BqCIXeNrK/T94jEtZ7hNUHQv9/oNs+yd897xHu9x6hbdH3g6h+jrDu8x6RcN4jrP8P9O8sderUkW4bG+8RBDYAAAAAJIoaG/qlTwdm9Gov62pH60pU/XIX3hVjuXPnNlNRde3a1enqPJ2KSq8y+/vvv6VAgQKmsLh1Jal1Vafe1ys0v/32W1ODQ7/oWXSwQL/AL1y4MNypqMLL2NBaIJcuXQp3DuG4mIpKBwb+/fdfyZQpE1NRJZApJKK7rR6H9mPNSNLtmWYm8U5FpQNpenU1U1ElzvcIPcdWH2AqqsT5HqHHZvWByM4ZU1El7PcI6/8Dzcyx+k9cTkWln4/1Mwk1NgAAAAAk6IwN/fLp6+srq1evtgc29EuS3u/cuXOEU0noesfAhqb563KVL18+yZYtm9nGCmzolyytnaFp+dY+NHCi9T30+dWaNWvMc2stjvDodFPhTTmlwRC9PU5UtnmSbfUc6vZRKRAZXvvjelvHAQd32FbPq+NATXzbVvusDmbpNtYtOvt1HDSL79sqxznk3WHb2Pq7D72t9gP9OwzvvSA+/N3zHhH722q/jKgPPM1+Xf13z3tE1LfV9wEdINdzFp39xoe/e94jYm5b6/8DxwBEbLYh9N8nNTYAAAAAJIrAhtLsC83Q0Pmsdf7tcePGmbT21q1bm/U6Z7TOJ2zNWa3zFmv2xejRo8381/PnzzfzHH/99ddmvX6p16DH4MGDpVChQibQ8dlnn5l5563gic5x/fLLL0u7du1k6tSp5kpBDaRoYXHdDgAAAAAAAAAAxB23Cmw0b97cpMz379/fFO7WLIsVK1bYi3+fOXPG6erTypUry7x586Rfv36mmKQGL3QaqpIlS9q3+eSTT0xwRItjamZG1apVzT4dr2D8/vvvTTCjVq1aZv9NmzaVCRMmxPHRAwAAAAAAAAAAt6mx4c50eisfHx+XziFsFd/MkiVLlKaiQsJDH4CiH4A+APoA4kM/iA+fjwEAAAC4L77NAgAAAAAAAAAAt0FgAwAAAAAAAAAAuA0CGwAAAAAAAAAAwG0Q2AAAAAAAAAAAAG6DwAYAAAAAAAAAAHAbBDYAAAAAAAAAAIDbILABAAAAAAAAAADcBoENAAAAAAAAAADgNghsAAAAAAAAAAAAt0FgAwAAAAAAAAAAuA0CGwAAAAAAAAAAwG0Q2AAAAAAAAAAAAG6DwAYAAAAAAAAAAHAbBDYAAAAAAAAAAIDbILABAAAAAAAAAADcBoENAAAAAAAAAADgNghsAAAAAAAAAAAAt0FgAwAAAAAAAAAAuA0CGwAAAAAAAAAAwG0Q2AAAAAAAAAAAAG6DwAYAAAAAAAAAAHAbBDYAAAAAAAAAAIDbILABAAAAAAAAAADcBoENAAAAAAAAAADgNghsAAAAAAAAAAAAt0FgAwAAAAAAAAAAuA0CGwAAAAAAAAAAwG0Q2AAAAAAAAAAAAG6DwAYAAAAAAAAAAHAbBDYAAAAAAAAAAIDbILABAAAAAAAAAADcBoENAAAAAAAAAADgNghsAAAAAAAAAAAAt0FgAwAAAAAAAAAAuA0CGwAAAAAAAAAAwG0Q2AAAAAAAAAAAAG6DwAYAAAAAAAAAAHAbBDYAAAAAAAAAAIDbILABAAAAAAAAAADcBoENAAAAAAAAAADgNghsAAAAAAAAAAAAt0FgAwAAAAAAAAAAuA0CGwAAAAAAAI/xzz//iIeHh/22bt06+7rPP//cvjxv3rzR3vfTPh4AgMSGwAYAAAAAIN7SwWPHweRZs2a5ukl4Sg8ePJDp06dLw4YNJVeuXJIiRQpJnjy5GdB/7bXXZObMmXLv3j1JKAhaAAAQ85LEwj4BAAAAAADC2LBhg7zzzjty7ty5MOtOnz5tbkuWLDFBgFatWom7qFOnjqROndr87uPjE+ePBwAgsSGwAQAAAAAAYt3GjRvNAP7Dhw/ty55//nl58cUXzaD+v//+K2vWrJEjR46Iu6lcubK5uerxAAAkNkxFBQAAAABIUL799ltp1qyZFCtWTDJlyiRJkyaVtGnTSpkyZaRXr15y9erVMI/RKYKs6YJ06qDdu3fLK6+8IunSpZOUKVNKtWrVZNOmTeE+39KlS6VChQpmSqWsWbNKu3bt5MqVK/LCCy/Y9+mYfRB6ei2t3RBZWyyBgYHy2WefSf369aVAgQKmbXpsGTNmNO2bOHGiBAQEhNvGGTNmSKlSpcyUTzr9U48ePeTu3bsRPpdl//798t5775nn0+PTAETZsmVl6NCh5vFRpcGMli1b2oManp6e8t1338nWrVvNvvr27StfffWVHD58WP744w/zfI7u378vY8eOlSpVqkj69OnF29vbnGs9Fz/++GOY5wt9jv/++2+ZPHmyPPvss+YcZMmSRdq2bSs3btwI81idBqt3797mPOm2JUqUkEmTJonNZovWdFNWGwYOHGjfTjNSwpta7XHTVWk7v/jiCylfvrzJ6NDjz5kzp5m6a9WqVWG21/06Po+e9yFDhkjhwoUlWbJk8swzz5g+4BhksvrYuHHjpFKlSqZ/JUmSxPQvPQf6+s2fPz/C49YbAABxhYwNAAAAAECCogPYGphwdPv2bTNIr7fvv/9eduzYITly5Aj38b/99psZbHcMEmhQo3bt2rJ3714TMLFMnTpVPvjgA6f6ERpE0MwDDQTEJN334MGDwyy/fv26aZ/eli1bJitWrBAvLy/7+j59+siXX35pv6/TQI0ePdpkUOg+IzJlyhT56KOPzGC3o3379pmbnsfVq1dLtmzZHtt2Df44BnA6deokLVq0CHfbWrVqOd2/ePGiOfeHDh1yWn758mXzWulNgxs66K4D8eHx8/NzCkxp4Ombb76REydOyPr16+3L9TV/+eWXzbmxaLClc+fO0qBBA3EFzWDRTJfQ03dphotO26W3Ll26mIBERPT8OR7/+fPnTR/Qc6gBJosGe2bPnh2mf+lNz8Px48flzTffjNHjAwDgSRDYAAAAAAAkKHo1/quvvmqu+s+QIYMZ5NeB3AULFsi1a9fM7xog0ABIeDTooVe0ay2Is2fPyrx588xyvbp9/PjxJpihdKC5W7du9selSpXKDAxrNoIOmvv7+8focekV8fnz5zfTN+nV+pq5oAPxR48elYULF5oAhGY7/PTTTyZjRe3cuVOGDx/udG50kF8DPZrZ8ujRo3Cfa8uWLWYwPzg42NzX59QBf32cDnxr1osOdOtV/L///vtj264BEEeaBRJV+jo4BjVef/11KV68uMlU0IwPpceswaj+/fuHuw8d1NeAiU73pEGWgwcP2mt+bNu2zRyf0tfXMaih2SmaufPnn3+aAEJ0aP8bOXKkOT9WVoW+ZpqdYnnuueci3Ye+pk2aNLEHNbQva0BI+6ceh7bLane5cuXM6xHR8et+9LxpQMoKMunvGvTSIN+dO3dk7ty59sc0bdrU7PPWrVsm08QxAAQAgKsR2AAAAAAAJCjLly830wnpoLdOQaQDtvny5ZOqVavKzz//bLZZuXJlhI/XAMX27dvtGR26Lx1EtgIFFh0Edsx4WLRokRn8Vw0bNjS1I2KStuvkyZPmKnsdjNcAjbZNB591oN4a5NZjswIbGmCxplDSgItmkui0QqpixYrSunXrcJ9r1KhR9qCGTqmlgQl9vGrevLmZekvpgP2BAwfMFE+R0bY6Klq0aJSOWTNDtM2WTz75xB6o0SCGTsFlBTd0cL9fv372djrSQX0NfmhwqGvXribAExQUZH9NrcCGZttYChYsaPatUzep9u3by/Tp0yWqrCm/tP9ZgQ2dEk2XRdWvv/4qx44ds9/X6casDCENkGj2kAYd1JgxYyIMbOgx61Re6o033jDTsil9jTW7Sfu6Bsmsc6Lt1ICeTnll0X4Ueto0AABchcAGAAAAACBB0QHeAQMGmAHliISe1sdRo0aNnKapKlKkiP13x5oMu3btsv+eOXNme1DDCgZorYSYHAjWOhMdO3Y0UwdZQYfHHZtjG319fe1BDfXuu++aeiChp5pSmzdvtv+utSIcp7YKL7vjcYGNJ2UFLSyabWLRNukxWNvodEkaBHCcKsyiwQCrBoRm8WjtlUuXLjm9ptpfHIMImrFgBTWUPld0AhuxcfyOgQud6kwDWJoVojTApIEurQkTmvab8Pqz4/FrNon2D82O0WwjDQZqRkmhQoVMfRbNeNFloWtshFebBQCA2EbxcAAAAABAgqGZFR9//HGkQQ0V0RRMKnTxZsfBbceAws2bN+2/h1dnIiq1J1TootShCzo71srQotCRBTVCPz6yNmo9Ch3gD48GCaJK61U8jk6d5Uinz4qK0O3QguGR3Q+vGHhUX1PHc6U0qyOy54oLjsevhds1ayeiNmk/Cn0M4R2/47Erx/6kWRo6XZVVw0MznDR7RwNKuXPnlu7du8fAUQEA8PTI2AAAAAAAJBhaR8NxIHjx4sVmuqLkyZObmhpatPpxkiZN6nTfutI/tHTp0tl/1+mhQtOi1+EJPVWSZmJY9Ep5K5MgsmPTK+h/+OEHc/W9Bij0yn2tsxGdNmqmhtbKCI9mNVjb6xRemsUSEa1b8Th6tb9jtoMGaCIrdu3YDkd6bjJmzOh035FmHTzpa+rj4+N0P/T5iuh1iU2Ox6/Burt37zoFNxzbpMfk+HpHdPwR9WelmTeasaFTm+3Zs8cUV9efWqBdAyA6nZXWr4npadYAAIguMjYAAAAAAAmGFge3aKHtl156yQQ1dFBWa2DEpPLlyzsNMK9du9Zp+qaIpqEKPfis9TIsw4YNC5PBEd6x6cCyThukQQ3NmNDne1wbdVqqv/76y6lGSHjTUIUOVmiARutLaG0Ix5sGiTSrISqBjcaNG0uePHns97/66it7UfbQtJ6HVcA79L61cLlF60E4FrvWIEDoaZaiI02aNE6P15ocjtkvjs8VHY5BBZ0qKjpCH79OQ+YYEPvxxx/t90uXLh3uNFTRoTVNrMCZZmkMHjzY1KxxnGpMAx0WnYZKAyXWDQCAuELGBgAAAADAbQwcONAMioemNTGWLVtmBqatQs1ac+Ctt94yNRf0inPHAEJMaNGihWmPVUBcB+/btGljL9odES2crYPot2/fttc/0CLRGkAIXVPBkR6bVSBcsx8080MHsufMmRPhdFDanq+//toESzQQUL16dVOnQTNDImujTuel0xDp4zQYUrJkSXnttdfM1Ee3bt0yV/SvX7/eZBBEVLDakU5/pFkadevWNdOAaVveeecd81pqkEaza7TAuBYKP3LkiMycOdNk2uhgvWZ7aLBDjRgxwhSE16DO77//7nS+unTpEm7h8OjQ86UFypUed6VKlUyGgp53zf55Eo7TcOnrpAXbdbonDQRocEhrZUSkQYMG5nW3an98+OGHpti57lOnXbMKh6tu3brJ09Ii6vq3pOdef2oR8f3795u/JUtEWSEAAMQlAhsAAAAAALehWRDhZUJYUyrp4LZe1W8FDebPn29+amaDDqR///33MdYWHVzWqXm0MLXSYIHeV5qdoOt1kF45Drh7e3ubdurV8EqzApYsWWLPsDhz5ky4U1t9+umnJlBjXa1vTeWUPXt2k5liBXQcafHnXr16yZdffmnuX7hwQYYPH25+L1eunAkmWNMZObZRp5/SoIO2U7M6zp49K+PHj3+q86UF1VesWGGKcGv9BqWBiciCOVamhAY3Dh8+bO5r5k3o7Bst9N23b195Wl27djUBAy2Irvbu3WtuVvsjyoyJjBaV1wCUla2hAR5Lq1atIg1saL/VvlGnTh1TFF4DQhr0Ce2jjz6KUoApKk6dOmVu4dHi4a+//nqMPA8AAE+DqagAAAAAAAlGwYIFZcOGDWYgWAeTNROgRo0a5or/2rVrx/jzdejQwVzJrwEJzUrQYtyayaGD9Y5FmUNf5f7FF1/I0KFDzUCxTlWkgRAtDq5ZEBENdL/55ptm6iHNYtDHaK2J5s2bm0wUvbo+Ijq9lWZtaJaDBlU0ENK5c2dzTjQYE1EbNZNEB/V1GqrChQub86kD7Zq1oef0s88+M1fzR4dmZ2jdhqlTp5psBA3+6FRh2i49B2+88YapFaLH5Vj0XLMURo8ebTIotBaGtiNz5swmaKDBKw106LKnpedVM0F69uxp2qbt0owJfe4ZM2Y80T61/b/88otUqVIlTPHvqNCMIz3POu2TBqO0T+ux6uvYpEkTWbly5VMHnSxTpkwxGSU69ZSeX30efT69r5ks27dvD1OLBAAAV/CwRTR5J2KMflDU//g1XVfTOF1BP1DrFT86/+nTpubCPdEHoOgHoA+APoD40A/iw+djIKZo5kR4gQitVaDBDr3CXmmmyNtvvx2v2qjTX+k0S5bNmzdHqV4GAACAqzEVFQAAAAAAT0gzIbTGhU7PU6BAAfHy8jL1GCZOnGgPajzzzDPmynpX0SmaNNCiQQzNENGppbSQ+OTJk+3baBBGsyEAAADcAYENAAAAAACekE6CsHv3bnMLj07bpEW4I6ujEBdt1NoQEdWH0Om7dPonLWYNAADgDghsAAAAAADwhLSgtBaA1mLTWoT7zp07Zoq1okWLmhoSWlg8Q4YMLm1j48aNTdu0PsKVK1fkwYMHpp5GyZIlTSZJ27ZtTf0MAAAAd0FgAwAAAACAJ1SmTBmZOXOmxPfgi94AAAASCipGAgAAAAAAAAAAt0FgAwAAAAAAAAAAuA0CGwAAAAAAAAAAwG0Q2AAAAAAAAAAAAG6DwAYAAAAAAAAAAHAbBDYAAAAAAAAAAIDbILABAAAAAAAAAADcBoENAAAAAAAAAADgNtwmsHH9+nV55513JG3atJIuXTpp06aN3LlzJ9LHPHjwQDp16iQZM2aU1KlTS9OmTeXSpUtO25w5c0YaNGggKVOmlCxZskjPnj0lMDDQvn7x4sXy0ksvSebMmc1zV6pUSVauXBlrxwkAAAAAAAAAABJAYEODGocOHZJVq1bJr7/+Khs2bJD27dtH+phu3brJL7/8IgsXLpT169fLv//+K6+99pp9fVBQkAlqPHr0SLZs2SKzZ8+WWbNmSf/+/e3b6PNoYGP58uWye/duefHFF+XVV1+VvXv3xurxAgAAAAAAAACAsDxsNptN4rkjR45I8eLFZefOnVK+fHmzbMWKFVK/fn05d+6c5MiRI8xjbt26ZbIs5s2bJ6+//rpZdvToUSlWrJhs3bpVnn/+efntt9/klVdeMQGPrFmzmm2mTp0qvXr1kitXroi3t3e47SlRooQ0b97cKQASGX9/f/Hx8TFt0qwPVwgODpbLly+brBRPT7eJZyEG0Qeg6AegD4A+gPjQD+LD52MAAAAA7sstvs1qIEKnn7KCGqp27drmS9j27dvDfYxmVwQEBJjtLEWLFpXcuXOb/Vn7LVWqlD2ooerWrWu+aGl2SERfAm/fvi0ZMmSIwSMEAAAAAAAAAABRkUTcwMWLF83VZI6SJEliggu6LqLHaMaFBkQcaRDDeoz+dAxqWOutdeEZNWqUqe3RrFmzCNv78OFDc7NooMQKiujNFfR5NTnHVc8P16MPQNEPQB8AfQDxoR/Q/wAAAAC4bWCjd+/eMnz48MdOQxVf6LRWAwcOlJ9//jlMoMXRsGHDzHah6fRWWtDcVV8eNdVfv8Ay7UTiRB+Aoh+APgD6AOJDP9AMaAAAAABwy8DGxx9/LK1atYp0m/z580u2bNnMHMCOAgMD5fr162ZdeHS5FgW/efOmU9bGpUuX7I/Rnzt27HB6nK631jmaP3++tG3b1hQid5zeKjx9+vSR7t27O2Vs5MqVy9T8cGWNDQ8PD9MGBjESJ/oAFP0A9AHQBxAf+kHy5Mnj/DkBAAAAJBwuDWzoFym9PU6lSpVMgELrZvj6+ppla9asMV/IKlasGO5jdLukSZPK6tWrpWnTpmbZsWPH5MyZM2Z/1n6HDBliL5yoVq1aZYIPWqzc8sMPP8h7771nghsNGjR4bHuTJUtmbqHpl0ZXDiDol1dXtwGuRR+Aoh+APgD6AFzdD+h7AAAAAJ6GW3yjKFasmLz88svSrl07k2GxefNm6dy5s7z55puSI0cOs8358+dNcXArA8PHx0fatGljMifWrl1rgiKtW7c2wYznn3/ebFOnTh0TwGjRooXs379fVq5cKf369ZNOnTrZAxM6/VTLli1l9OjRJoiitTf0pqn7AAAAAAAAAAAgbrlFYEN9//33JnBRq1YtqV+/vlStWlW+/vpr+/qAgACTkXHv3j37srFjx8orr7xiMjaqV69uppdavHixfb2Xl5f8+uuv5qcGPN59910TxPjiiy/s2+hz6LRXGuzInj27/dalS5c4PHoAAAAAAAAAAKA8bFoxELFKa2xoBolmebiyxoY15Rap/4kTfQCKfgD6AOgDiA/9ID58PgYAAADgvvg2CwAAAAAAAAAA3AaBDQAAAAAAAAAA4DYIbAAAAAAAAAAAALdBYAMAAAAAAAAAALgNAhsAAAAAAAAAAMBtENgAAAAAAAAAAABug8AGAAAAAAAAAABwGwQ2AAAAAAAAAACA2yCwAQAAAAAAAAAA3AaBDQAAAAAAAAAA4DYIbAAAAAAAAAAAALdBYAMAAAAAAAAAALgNAhsAAAAAAAAAAMBtENgAAAAAAAAAAABug8AGAAAAAAAAAABwGwQ2AAAAAAAAAACA2yCwAQAAAAAAAAAA3AaBDQAAAAAAAAAA4DYIbAAAAAAAAAAAALdBYAMAAAAAAAAAALgNAhsAAAAAAAAAAMBtENgAAAAAAAAAAABug8AGAAAAAAAAAABwGwQ2AAAAAAAAAACA2yCwAQAAAAAAAAAA3AaBDQAAAAAAAAAA4DYIbAAAAAAAAAAAALdBYAMAAAAAAAAAALgNAhsAAAAAAAAAAMBtENgAAAAAAAAAAABug8AGAAAAAAAAAABwGwQ2AAAAAAAAAACA2yCwAQAAAAAAAAAA3AaBDQAAAAAAAAAA4DYIbAAAAAAAAAAAALdBYAMAAAAAAAAAALgNAhsAAAAAAAAAACBhBzZu3rwpM2bMkD59+sj1660glAwAAGO7SURBVNfNsj179sj58+djun0AAAAAAAAAAAB2SSSaDhw4ILVr1xYfHx/5559/pF27dpIhQwZZvHixnDlzRr777rvo7hIAAAAAAAAAACB2Mja6d+8urVq1khMnTkjy5Mnty+vXry8bNmyI7u4AAAAAAAAAAABiL7Cxc+dOef/998Msz5kzp1y8eDG6uwMAAAAAAAAAAIi9wEayZMnE398/zPLjx49L5syZo7s7AAAAAAAAAACA2AtsNGzYUL744gsJCAgw9z08PExtjV69eknTpk2juzsAAAAAAAAAAIDYC2yMHj1a7ty5I1myZJH79+9LjRo1pGDBgpImTRoZMmRIdHcHAAAAAAAAAAAQZUkkmnx8fGTVqlWyefNm2b9/vwlylCtXTmrXrh3dXQEAAAAAAAAAAMRuxoalSpUq0rFjR/nkk08IagAAAAAA4Cb+ufmPeAz0kFn7Zok70HZqe3f9u8vVTXE7rZa2krzj8sbIvl6Y9YKUnFxS4kt/0H4cmc/XfW62S6yvV3TOFQAkisDGRx99JBMmTAiz/KuvvpKuXbvGVLsAAAAAALA7ef2kvP/L+5J/fH5JPji5pB2WVqp8W0XGbxsv9wPui7s5fOWwGXh92gFHHWzWwVClP/W+u5q8c7LbBFuAhE7fn6wgixUgAQC3Dmz89NNPJlsjtMqVK8uiRYtiql0AAAAAABj/O/4/KTWllPx4+Ed5tfCrMrHeRBlWa5jk9sktPVf1lC4ruog7BjYGrh/IldQOCGzEvOmvTpdjnY9JYtSvej+5/6l7BT0T8+sFALFeY+PatWumzkZoadOmlatXr0a7AQAAAAAAROTUjVPy5k9vSp50eWRNyzWSPU12+7pOFTrJXy/+ZQIfT8tms8mDwAeSImmKMOt0ubeXt3h6PPFszm7p7qO7kso7laubkWAE24LlUdAjSZ4keZw9Z1KvpJJYJfFMYm7uJCqvV2BwoOlL+p4EAIlZtD+VFSxYUFasWBFm+W+//Sb58+ePqXYBAAAAACAjNo+QO4/uyDcNv3EKalgKZigoXZ7v4jToN2j9ICkwoYAkG5zMTKXSd3VfeRj40OlxuvyVea/Iyr9WSvmvy0uKISlk2u5psu6fdWbKlfl/zpd+a/pJzjE5JeWQlOL/0N88bvu57fLy3JfF50sfs7zGrBqy+czmMO06739e2vzcRnKMzmHakW98Pvng1w/MwLZmJbyx8A2z3YuzXzTPpzd9bnXrwS05evWo+fm0bj64aaao0vam+zKd+C31M8tC021SD01tpvyq/319STMsjbyz+B2zbuPpjaa9ucfmNseSa2wu6baiW7hTgC08tFCKTypupgvTegxLjiyJUt0AXX/oyiFZf3q9/XyEnlZLX8PuK7tL5pGZJdXQVNJkQRO5cvdKmH39duI3qTazmtlGj6PBvAZy6PKhKJ8vPTZtjx7rM2OekZZLWsrVe1ed2jFg7QApOKGg/Xx8suqTMH1Mj6Hz8s7y/YHvpcTkEmbbFX+FjKeM2jJKKn9TWTKOyGj6nu/XvrLocNhZMKx9WOdVt630TSU5eOmgWT9t1zTTDj3fer5CZwCFd+51UFyncNMsKH2cnk/t01GtYbL7392m7doW7ddTd00Ns83lu5dN/886Kqt5jtJTS8vsfbOdtik3rZy8tuA1p2XaJj3mA5cO2Jct+HOBWXbkyhGJjvBqbFjnc+nRpaZ/6muir431ukRG/3b7r+1vXiv9e9L+pf1s7am1UW6T9k19z9B+qdPpPTf9OZl3cF6Er5dVD0f7y7ht4+zva5rxpfR9otnCZuY11NejyFdF5NPVn0apHU/6NwIA8UW0Q9fdu3eXzp07y5UrV6RmzZpm2erVq2X06NEybty42GgjAAAAACCR+uX4L5I/fX6pnKtylLZvu6ytzN4/W14v/rp8XOlj2X5+uwzbNEyOXD0iS5ovcdr22LVj8tZPb8n7vu9Lu3LtpEimIvZ1gzYMMldE96jUQx4GPTS/rzm1Rup9X098s/vKgBoDTAbHzH0zpeZ3NWVj641SIWcF89h/b/8rFWZUMIPk7cu1l6KZisr52+fNwPW9gHtSPU91+ajCRzJhxwTpW7WvFMtczDyuWKaQn0uOLpHWP7eWmY1mSqsyIfUznjQLpdH8RrLpzCbp4NvBPI/uW4Mb4dGgUN25daVq7qoy6qVRkjJpSrN84eGFpt0flP9AMqbMKDvO75CJOybKudvnZOEbC+2P18yZ5ouaS6mspcxUYTce3JA2y9pIzrQ5H9vWcS+Pkw9/+1BSe6eWT6uFDMxmTZXVaRtdnz5FenPudcBXB3o7e3WWBa8vsG8zZ/8cc3x1C9aV4bWHm3ZP2TVFqs6sKnvf3yt500UcYNEAmg726gD6e2Xfk3LZy5mAxrJjy+Sc/znJlDKTCQo0nN/QnFN9bfWcapBh7LaxcvzacVn65lKnfWqf+fHQj9K5QmfzeOv5x28fLw0LN5R3Sr1jBsznH5pvgke/vvWrNCjcwGkfG89sNG3o9Fwnc1/78ys/vCKfVP5EJu+aLB2f6yg37t+QEVtGyHs/vydr/NZEeq71NdHgWr2C9aRt2bbmddfn2HZum5TPUT7Sx+prWn9efWlWvJm8VfItMz3cB//7wPx96DlTGvDSIMtf1/8yx50vXT7Th1r93Mr8TViByGq5q8kPf/5g3/f1+9fN4Lr+XWkw7dmsz9qPP3PKzPa/k6elr93iI4vNeUvjncb8HTb9samc6XrG9O+IaHBzxp4Z5rj1/eL2w9vyzd5vzN/MjnY7pEy2MpE+r55zfX1KZCkhfar2kXTJ08neC3tNUOXtUm9H+lh9n9HMMe1zyZIkkwwpMpjgj/bXpJ5Jpb1ve9O3NDCp75lDag2JcF9P8zcCAPGK7QlMnjzZljNnTpuHh4e55cuXzzZ79uwn2VWicOvWLZueav3pKkFBQbYLFy6Yn0ic6ANQ9APQB0AfQHzoB/Hh8zHcw60Ht2zyudga/dAoStvvu7DPbN/257ZOy3us7GGWr/l7jX1ZnrF5zLIVJ1Y4bbv21FqzPP/4/LZ7j+7ZlwcHB9sKTShkqzunrvndotvkG5fP9tJ3L9mXtVzS0uY50NO28/zOMG20Hrvw0ELzPPp8oc3cO9Os059PY+mRpWY/IzaNsC8LDAq0Vfu2Wpj9+y3xM8t6r+odZj+O58EybOMwm8fnHrbTN0/bl5WaXMr2zJhnbLcf3rYvW3dqndmvnu/HKTGphK3GzBoRno/a39V2OvfdVnSzeQ30st28f9Pc1+dN92U6W7tl7Zwef/H2RZvPMJ8wy0Prv6a/eZ7FhxeHWWc975z9c8xru/H0Rqf1U3dONY/dfGazfZne120PXT702HP6KPCRreTkkraas2s6Ldd9JBuUzHbqxin7smm7ppnl2UZls/k/8Lcv7/NHH7PccVt9XR3Pvf4N6DYfLf8owmOMiL42+tjRW0bblz0MfGgrM7WMLcvILOYY1Lit48x2c/fPdTq+SjMq2VIPTW1vs/U3cPjyYXN/2dFl5lgb/tDQ1nxhc/tjn53yrK3J/CZh+oPjcYZnwNoBZjtHet97kLftr2t/2Zftv7jfLJ+4fWKk+9O/HT1eRzfu37BlHZnV9t7S9yJ9rPbRNEPT2CpOr2i7H3A/wvMe+vXSY9S2pR2W1nb5zmWnx1WfWd3s0/FvMPT+Qp+rp/0bAYD45IkmCP3ggw/k3LlzcunSJfH395e///5bWrZsGfNRFwAAAABAomVN/5QmWZoobb/8xHLzs3ul7k7LP678sfn5vxPOtTj0SnK9ajk8fqX9nOpt7Lu4T05cP2GurL52/5q5kl9vdwPuSq18tWTD6Q3man696TQ3WuQ8vKvfPTycp8YJj2Zp2AbYnipbwzofWmPgg+c+sC/z8vSSDyt8GOFjHLe1OJ4Hrbuhx60ZNDaxmSvOrSyVg5cPSstnW5qsC0uNvDWkVJZSEhP0anXH86dX/AfZguT0rdPm/qqTq0xGgF5Rb70+etNjrvhMRVn7T+RTBv105CcpnbW0NCnWJMw663k180AzazQLx/E5auYLmdEi9LRENfLUkOKZi0d6TjXb4tbDW+Z49lzYE2bbWvlrOV1FXzFnRfOzabGmTn8b1vK/b/wd6TF6iIcMeGFAhMcYGe1PmuFk0UwNva9TT+2+sNssW/7XcsmWOpu8Veotp9oRH1X8yGTF6HRjSo9X6d+OlZnxXM7n5KX8L5nflb6ef17+075tTKidv7YUyFDAfl8zQ9ImSxvpeVPaj6y6Fvp3rhkmmu2if+d7LoZ93Ryt+nuV3H50W3pX7R2mxkpUzru+1plTZbbf1ynY9Lxplkxun9xR3t/T/o0AQHzyVFWUMmf+700VAAAAAICYpIONSqd8iQod4NZpbLTuhiMdZNVpX6wBcEu+9Pki3JcGPRxpUENFNI2T0poYOq2QBmRKZikprqbHmz11dqdAg3Kcciv0oPUzaZ8Js/zMrTOmtoBOh6RTETnSAXnzXDdDzm3oc28tC2/APrpCD+DqtFRWYMDxNdKpwSLrTxE5eeOkGUCOzIlrJ8y0ZlrTIDw6wB9ZP7L8evxXGbxhsAmY6VRnFg06hJY7rfNx+yT3MT9zpc0V7nLrfER0jDnS5DBTGT0JfWzogvKFMxY2P3V6sOefed70hUIZCpm/RUfWVGtWX8maOqvZToMY75d/3/x8Me+LZqo2nXZMAw06LZgGEarlibnARujzqdInTx+mb4dH64SM3jra1LYICA547Ots0Smi1JO+L4TevxWEie7+nvZvBADcOrChWRo9evQwdTUuX75s5ux0FBQUFJPtAwAAAAAkUjrIpgOpesV2dETlCmiVIkmKiNc5XFGvdHBVjXxpZIRz6WsAQa/idlfJvJKFGYwOCg6Sl+a8ZI6rV5VeJlNBB7a1OLrWTLDOS1zQq8rDo5kjymrLnCZzTDArvMDN09Ln0AyUMXXHhLs+dLAhdD9SWj+i4Q8NzQD+5AaTTfBJMxq0joJjIenHHffjzoc70Houq0+tNnU5tCh5/+r9zWC9BiL1PGkQSf+uymYrG2PPGeF5CzW+FdrcA3NNn29ctLH0rNxTsqTKYvalNU+swEVsCa8fPYm4+BsBgLgS7XesVq1ayZkzZ+Szzz6T7NmzR/kDIwAAAAAA0fVKoVfk6z1fy9azW6VSrkqRbpvHJ48ZuNOr6h0LDV+6c8lMv6Lrn1SB9AXswRadyiYiOl2MbvO4YEx4V+bHND1eHTTW6X8cszaOXT0W5X3o9FJaFHt249nSsnRLpyltnJ4rXci51YLRoYW3LDxPO75gvUY64BzZaxTZ4x/3uukURvsv7jfTjz1pe3U6KJ2OaOW7K00haIsGNmKbHuPKv1aaQNWTZG3olGM6HZlj1ob2D2VNl6V9QQtb69+iY6BMsxys9RadYkqPe/6f8820YjrFmT5GAx6awaGBDV0WUTAiLi06vEjyp88vi5stdnrtB6wLO61XaNbUV9q/wstqii5th7W/uPwbAYD4JNo1NjZt2iTff/+9qbPRuHFjadSokdMNAAAAAICY8kmVTyRV0lTS9pe2JkARml4pPX7bePN7/UL1zc9x28Y5bTNma8jV9Q0KNXjidvjm8DWDgqO2jDKBgtB0znulg7J6Rfcvx3+RXf/uivCqcGtgWAMu4U1ppYPA+vNp6PnQGgBTdk5xysCYuGNilPfh5eEV5mp2/X389pBzbtHMGr3S/rsD3zmdn/X/rDfBkajQ1zm88xFVWi9Fg0pDNw6VgKD/pgkK/RpFRKeh2n9pvyw5siTMOuv4mxVvJudvn5fpe6aH2UazDnTQPyrnVAfGdSDfotM4aW2W2KbHqBkdA9cNjHbGgtL+NG33NPt9nXpN72dOmVl8s/uaZfUL1peLdy7Kgj8XOD1O+50G2LTuiMWaYmr45uGm1oU1nZYGPDQop39DMVlf42lYwRXHjJjt57aboOvj1ClQR9J4pzHZHQ8CH0T7vIcXQNWMn2/3fmumiovq/p72bwQA3DpjI1euXE/0pgsAAAAAQHTplc7zms6T5ouaS7FJxUzWgA6g64DqlrNbTDHnVqVDimyXzlbaFP3WDI+bD2+aAdQd53fI7P2zTbDhxXwvPnE7NGAxo+EMqfd9PSkxuYS0LtNacqbJaQa5teCuDhb+8tYvZtuhNYfK7yd/lxqzapiC15o9cuH2BdPWTe9tMtPs6HRWOsCtA7oawNAr97UAtV5JveToEmn9c2uZ2WjmUxUQf7XIq1IlVxXpvbq3GTjXItaLjy6218WICp16SgM6PVb1MMeqx6kZB+HVcdDjbjS/kVT5too5P7rNVzu/Mq9XeMGg0HRgfMquKab2hF7VrufCKsodFdq2KQ2mSIslLaTc1+XkzRJvmgFgHfjVwvF6Lr6q/1WEj+9ZpacsOrJI3lj4hinKrO3RzIZlx5fJ1AZTTf9qUbqF/Hj4R+nwawfzuus+NVikgShdrlkY4RWNd9SgcAMZs22MvDz3ZVOMXutyTNo5yRyzZjrEJv0baPFsC5mwY4Kpt/BywZdNZoVV36Jzhc6RPl4DWNpntT9pbY0FhxaYOiFfv/K1mU5Ltfdtb4IdOm2TFhTXTA7Ndth8drOMqzvOqeC5HrNOiXTs2jGnovY6aN/rj17m9/gS2NDsscVHFkuTBU1MkPTUjVMydfdU83f1uP6tfXNs3bEmQPvc9Ofk7ZJvmxoxmv1zL/CeyYiKrgkvT5CqM6tKuWnlzDnXOhz6umhf39dhX6z8jQCAWwc2xo0bJ71795Zp06ZJ3rwhaYYAAAAAAMSWhkUayoEOB2TklpHy87GfzeC31oPQK7xH1xkt7cq1s2+rwQedpmXWvlnmynsdNO1TtY8MqPH46WIe54W8L8jWNltl0IZB8tWOr8xgpu6/4jMV5X3f9+3b5UybU7a33S6frf1Mvj/4vSkmrsvqFawnKZOmNNvo46a+MtVcwd1mWRtz9f5av7VmMD+maDBm2VvLpOuKrjL34Fwz/ZWeSz1nZadFrWaBDlZrwOajFR+ZtuoUSk2KNjED4KWnlg4TSPmh6Q/y+frPpfcfvaVQxkIyq9EsE1g6dOXQY5+rf43+puD5iM0j5Paj2yYwFZ3AhtJAgQ6+f7npS9NftDC3BqA0M0CDLZHRbIKNrTfKgLUDTHBJ262vh047ZRVV13O6tPlSGbttrHy3/zvTx/Q11T7XpWIXeyHtyOgxfdPwG9NGfW20iP3w2iHBgtgObCgNmOnfzjd7v5Geq3qKTzIfE4zRKZ8eR4ts6yC8FvfWrJWsqbLKV/W+kna+7ZzqQaxrtc70AT2H2v+LZCwSYaBOAxca9NPppywaVNLzqpke+vcVH2jbNRNFgzY6nZcGNOY2mWvavu6fdY99fJtybUx/+nLzl+Y9RP+2NHDY7fluT9QeDbRta7PNvM/oe6Jmguj0c81KNIu1vxEAiE88bNFMv0ifPr3cu3dPAgMDJWXKlJI0aUhE3nL9uvsWSost/v7+4uPjI7du3ZK0adO6pA3BwcGm2HuWLFnE0zPaM5AhAaAPQNEPQB8AfQDxoR/Eh8/HAOJOmallzFXhq1o41+UAAACI04wNAAAAAAAARzpnv9aOSOL531CDXsmudSsGvzjYpW0DAACJPLDh5+cXOy0BAAAAAABuS2tw1P6utrz77LtmqhutOzF111Qz7VaH8h1c3TwAAJCYAxvq5MmTMnPmTPNz/PjxJoX9t99+k9y5c0uJEiVivpUAAAAAACBe0/oLvjl8ZcaeGXLl3hVJlTSVKZT9Za0vJWPKjK5uHgAASMyBjfXr10u9evWkSpUqsmHDBhkyZIgJbOzfv1+++eYbWbRoUey0FAAAAAAAxFs+yX1kwesLXN0MAACQCES7UmDv3r1l8ODBsmrVKvH29rYvr1mzpmzbti2m2wcAAAAAAAAAAPDkgY2DBw9KkyZNwizXrI2rV69Gd3cAAAAAAAAAAACxF9hIly6dXLhwIczyvXv3Ss6cOaO7OwAAAAAAAAAAgNgLbLz55pvSq1cvuXjxonh4eEhwcLBs3rxZevToIS1btozu7gAAAAAAAAAAAGIvsDF06FApWrSo5MqVS+7cuSPFixeX6tWrS+XKlaVfv37R3R0AAAAAAAAAAECUJYn6piI2m81kakyYMEH69+9v6m1ocKNs2bJSqFCh6OwKAAAAAAAAAAAgdjM2NLBRsGBBOXfunMnYqF+/vjRr1ixOghrXr1+Xd955R9KmTWvqfLRp08YEVSLz4MED6dSpk2TMmFFSp04tTZs2lUuXLjltc+bMGWnQoIGkTJnSFEDv2bOnBAYGhrs/nXIrSZIkUqZMmRg9NgAAAAAAAAAAEAuBDU9PTxPEuHbtmsQ1DWocOnRIVq1aJb/++qts2LBB2rdvH+ljunXrJr/88ossXLhQ1q9fL//++6+89tpr9vVBQUEmqPHo0SPZsmWLzJ49W2bNmmWyUUK7efOmqSFSq1atWDk+AAAAAAAAAAAQCzU2vvzyS5PV8Oeff0pcOXLkiKxYsUJmzJghFStWlKpVq8rEiRNl/vz5JlgRnlu3bsk333wjY8aMkZo1a4qvr6/MnDnTBDC2bdtmtvn999/l8OHDMnfuXJOFUa9ePRk0aJBMmjTJBDscdejQQd5++22pVKlSnBwzAAAAAAAAAACIgcCGZi3s2LFDSpcuLSlSpJAMGTI43WLD1q1bzfRT5cuXty+rXbu2ySDZvn17uI/ZvXu3BAQEmO0sWvQ8d+7cZn/WfkuVKiVZs2a1b1O3bl3x9/c32SEWDYj8/fffMmDAgFg5PgAAAAAAAAAAEAvFw9W4ceMkrmnBcq1/4UhrXWggRddF9Bhvb28TEHGkQQzrMfrTMahhrbfWqRMnTkjv3r1l48aN5jmj4uHDh+Zm0UCJCg4ONjdX0OfVGimuen64Hn0Ain4A+gDoA4gP/YD+BwAAACBOAxt+fn4SUzRgMHz48MdOQ+UqWoNDp58aOHCgFC5cOMqPGzZsmHlMaFeuXDEFzV315VGn59IvsJrpgsSHPgBFPwB9APQBxId+cPv27Th/TgAAAACJOLChTp48aaZn0p/jx4832RS//fabmeapRIkSUd7Pxx9/LK1atYp0m/z580u2bNnk8uXLTssDAwPl+vXrZl14dLnWydCi345ZG5cuXbI/Rn/qtFqOdL21Tr9w7dq1S/bu3SudO3d2urpNsze0RofW7witT58+0r17d6eMjVy5cknmzJklbdq04grabg8PD9MGBjESJ/oAFP0A9AHQBxAf+kHy5Mnj/DkBAAAAJOLAxvr1602R7SpVqsiGDRtkyJAhJrCxf/9+U6x70aJFUd6XfpHS2+NowW4NUGjdDC0CrtasWWO+kGkx8fDodkmTJpXVq1dL06ZNzbJjx47JmTNn7AXA9ae2X4Mm1lRXq1atMsGH4sWLm8cfPHjQab+TJ082z63HmS9fvnCfO1myZOYWmn5pdOUAgn55dXUb4Fr0ASj6AegDoA/A1f2AvgcAAADgaXg+yfRRgwcPNgEArWFh0cyFbdu2SWwoVqyYvPzyy9KuXTuTYbF582aTQfHmm29Kjhw5zDbnz583xcGtDAwfHx9p06aNyZxYu3atCYq0bt3aBDOef/55s02dOnVMAKNFixYmMLNy5Urp16+fdOrUyQQm9AtXyZIlnW4aANErzPT3VKlSxcrxAgAAAAAAAACAGApsaAZDkyZNwizXAf+rV69KbPn+++9N4KJWrVpSv359qVq1qnz99df29QEBASYj4969e/ZlY8eOlVdeecVkbFSvXt1ML7V48WL7ei8vL/n111/NTw14vPvuu9KyZUv54osvYu04AAAAAAAAAABAHE5FpfUqLly4EGYaJq1DkTNnToktGTJkkHnz5kW4Pm/evKb2hSPNrJg0aZK5RSRPnjyyfPnyKLfj888/NzcAAAAAAAAAAOAGGRs6/VOvXr3k4sWLZl5erXOhU0P16NHDZDsAAAAAAAAAAADEm8DG0KFDzZRQuXLlkjt37pgaFTrNU+XKlU19CgAAAAAAAAAAAJdOReXv7y9p06Y1v2vB8OnTp0v//v1NvQ0NbpQtW1YKFSoUa40EAAAAAAAAAACIcmAjffr0pq6GFgivWbOmKcCtGRt6AwAAAAAAAAAAiFdTUaVOnVquXbtmfl+3bp0EBATEdrsAAAAAAAAAAACeLGOjdu3a8uKLL0qxYsXM/SZNmpgpqcKzZs2aqOwSAAAAAAAAAAAgdgIbc+fOldmzZ8vJkydl/fr1UqJECUmZMmX0nw0AAAAAAAAAACC2Axs69VSHDh3M77t27ZLhw4dLunTpnuZ5AQAAAAAAAAAAYqfGhhYPv3z5svndw8Mj+s8CAAAAAAAAAADgiuLhOhUVxcMBAAAAAAAAAIBbFA+32WwUDwcAAAAAAAAAAC5B8XAAAAAAAAAAAJCwAhspUqSgeDgAAAAAAAAAAHCPwIajtWvXxk5LAAAAAAAAAAAAYiKw0b17dxk0aJCkSpXK/B6ZMWPGRGWXAAAAAAAAAAAAsRPY2Lt3rwQEBNh/j4iHh0f0WwAAAAAAAAAAABCTgQ3H6aeYigoAAAAAAAAAALiK55M8yGazydWrV+XatWsx3yIAAAAAAAAAAICYCGxcvHhRWrZsKenTp5esWbNKlixZzO/vvfeeXLp0KTq7AgAAAAAAAAAAiJ2pqJS/v79UrlxZ7ty5I61bt5aiRYuazI3Dhw/LDz/8IJs2bZI9e/ZI6tSpo98KAAAAAAAAAACAmAxsjB8/Xry8vOTQoUOSOXNmp3X9+vWTKlWqyIQJE6Rv375R3SUAAAAAAAAAAEDsTEX1v//9zwQtQgc1lE5J1adPH/nll1+i9+wAAAAAAAAAAACxEdg4fvy4mYoqIrru2LFj0XluAAAAAAAAAACA2AlsaI2NdOnSRbhe1+k2AAAAAAAAAAAALg9saKFwT8+IN/fw8DDbAAAAAAAAAAAAuLx4uAYtChcubAIYEa0HAAAAAAAAAACIF4GNmTNnxmpDAAAAAAAAAAAAYiyw4efnF9VNAQAAAAAAAAAAXFtjAwAAAAAAAAAAwNUIbAAAAAAAAAAAALdBYAMAAAAAAAAAALgNAhsAAAAAAAAAAMBtENgAAAAAAAAAAABuI0lUNurevXuUdzhmzJinaQ8AAAAAAAAAAMDTBTb27t3rdH/Pnj0SGBgoRYoUMfePHz8uXl5e4uvrG5XdAQAAAAAAAAAAxF5gY+3atU4ZGWnSpJHZs2dL+vTpzbIbN25I69atpVq1ak/WCgAAAAAAAAAAgNiosTF69GgZNmyYPaih9PfBgwebdQAAAAAAAAAAAPEmsOHv7y9XrlwJs1yX3b59O6baBQAAAAAAAAAA8PSBjSZNmphppxYvXiznzp0zt59++knatGkjr732WnR3BwAAAAAAAAAAELM1NhxNnTpVevToIW+//bYEBASE7CRJEhPYGDlyZHR3BwAAAAAAAAAAEDuBjaCgINm1a5cMGTLEBDFOnjxplhcoUEBSpUoVnV0BAAAAAAAAAADEbmDDy8tL6tSpI0eOHJF8+fLJs88+G/1nBAAAAAAAAAAAiKsaGyVLlpS///77SZ8PAAAAAAAAAAAg7gIbgwcPNjU2fv31V7lw4YL4+/s73QAAAAAAAAAAAOJN8fD69eubnw0bNhQPDw/7cpvNZu5rHQ4AAAAAAAAAAIB4EdhYu3ZtrDQEAAAAAAAAAAAgxgMbNWrUiO5DAAAAAACAu9DZGQYMEPn8c1e3BP/8I5Ivn8jMmSKtWkX/8bNmibRuLXLqlEjevLHRQgAA3KPGhuXevXty9OhROXDggNMNAAAAAIAYowOzOtC+a5erW+J6hw+HBBt0sPtpvPDCf4Pk+lPvA3FN+7IVbLH+zgEAiK2MjStXrkjr1q3lt99+C3c9NTYAAAAAAIilwMbAgSGBiNi8+v7+fZEk0R4uAAAAiL8ZG127dpWbN2/K9u3bJUWKFLJixQqZPXu2FCpUSJYtWxY7rQQAAAAAIL6x2UKCAOF58EAkOFjcUvLkBDYAAEDCCmysWbNGxowZI+XLlxdPT0/JkyePvPvuuzJixAgZNmxY7LQSAAAAAACLTp+UOrXI+fMijRuH/J45s0iPHjqNgPO2GlwYP16kVKmQAXvd7uWXnae2CgwUGTRIpEABkWTJQrIh+vYVefjQeV+6/JVXRFauFClfXiRFCpFp00TWrQuZRmf+fJF+/URy5hRJmVLE3z/kcdu3hzynj0/Icq1duXlz2OPS42nTRiRHjpB2aG2FDz4QefQoZKqeN94I2e7FF0OeT2/63OrWLZGjR0N+Pi3dr2N9DT3f4WWI6Dahpw/S+507iyxcKFK8eMg5qlRJ5ODBkPV6vgoWDHktNPMk9LRauqxkSZHdu0UqVw55vJ6HqVMf327dlz6/nqvHHZPVdj1nzZqJpE0rkjGjSJcuIUGpx9m4MeT1yJ075LXKlUukW7ewga7o9NWbN0O2136SLp2In1/Isqg6dEikZs2Qc/bMMyKDB0ccXJs8WaREiZC2a3/r1Mn5uSZMEPHycl42enTIOeve/b9legxp0oj06uX8GowaJfL11//9TT33nMjOnVE/FgAAHiPal2DcvXtXsmTJYn5Pnz69mZqqcOHCUqpUKdmzZ090dwcAAAAAQPTpgGrduiIVK4YMov7xR8jAqw6kajDAooECHeiuV0+kbduQIIYOSm/bFhKcULp89myR118X+fjjkECEXrh35IjIkiXOz3vsmMhbb4m8/75Iu3YiRYr8t06DI97eIYPWGhTR39esCXluX9+QgtyeniGFoHUA+v/auw/wqMrsj+MnPaEXCU0RERFdERTWhsqqCAqL64qu/mVBEUUUBCtiLyyirrL2rthwVVBRwaUoKnbsunbFXZReBEIJpMz/+b13L5kZJiHJTDK5yffzPPeZzJ3bZuYVk/fcc85bb5kdcIC375Il3s+aSB4+3KxzZ28yfNo0Nbk0O/xws9GjvQlnBV322svbz3/UdapJdGWbTCeS3pcqOmiyXPRZKiA0dqw3oX7uuWa//WZ2881mZ5zhfUbh9Fq/fl7AQZ/1s89636k+T22fSDqHgja6Ro0Jfb46/+OPl72fAjf6XnRdCogsWGB2551mv/7qvVbRsarsnz/9yeztt81GjPC+V32nCm6Ux7JlXsBL43vcOLP69b3AgoIc0RTUUUmz3r2982tM33uvF3hQwC0jw+yww7ygiK5H353/vWr86tH36admGzZ44zPcU0+Z5eV5/50o0KHv+oQTzBYu9I4PAEC8QhXUo0eP0KxZs9zPAwYMCA0ePDj066+/hsaOHRvq0KFDRQ9XJ6xbty6kj1qPyVJUVBRaunSpe0TdxBiAMA7AGABjADVhHNSE348RIJMna8o3FPrww5J1p53mrbv++sht99svFOreveT5vHnedqNHb3/c4mLv8bPPvG3OPDPy9Ysv9tbrGL5dd/XW/e9v4m1ef91br7+JN22KPMcee4RCffuWnE+0zW67hUJHH12ybsiQUCg1NfJ9Rl/r1KneeXS+0j4nPcZLx7nmmsjPW+89mraJnlbQ86ysUOjnn0vW3X+/t75Vq1Bo/fqS9Zdd5q0P37ZXL2/drbeWrNuyJRTq1i0Uys0NhbZuLf26dZzSPoPo9+Rf+3HHRW537rne+s8/D5Up/Hv2TZwYCqWkhEL//W/Fx+r06d52N99csq6wMBQ67LDyfa/nn+9t98EHJetWrAiFGjeO/Iy1LjMzFOrTR/8zKNn2rru87R55xHuu1xo1CoXGji0Zg82bh0InnRQKpaWFQnl53vpJk7xx+9tvkd+Btl2zpuT4L77orX/55bLfBwAA5VThUlRjxoyxpUuXup+vueYa10S8Xbt2dscdd9gNN9wQd6AFAAAAAIBy0Z3t4XSXue4I9z33nHe3uDIlovkllF55xXsML68jytyQmTMj16ssku6+j0V314ffIf/ZZ2Y//GB26qlmq1ebrVrlLRs3mh11lNn8+d5d8VqmTzcbMKAkiyTWtZZFWRqaOk52tobovYWXrlKmggwc6JUtil4f/p2J+nvoTn+fMjX0fMUKr0RVIvlZJb7zzoscF6UJ/571fep7VeksfQfKYqjoWNX59L7Ds41UCsq/nh3R/gcdVJIBJCp5NWhQ5HbKFlFps/PP97IvfMo+Ujkuf7zrNb0fjVFR9pLGsLJB9B7fe89br+wNlQ5T6axwJ5+sMh+R7zfWdw0AQHWVolI/DV/37t3tv//9r3377bcuuLHTTjtV9joAAAAAACg/v19GOE2kqoyQ76efvP4BzZqVfpz//tebxFXfh3CtWnmTtXo9OrBRmujXFNSQssoJqSeGJprVj0MTxLWB+k6EU88IUR+KWOvDvzPRd6ZSSuE6dSrp4aAJ/ETZY4/I5yoPpfEQ3fsj2qJFZldf7ZXcir7+6D4n5RmrGmetW3s9OMKFlzori/b3A0Vl7e+P5+j1Ch516BA53hWMUNkq9Q1RAEPXt//+Zl27es+PPtorVaVyXjsaA36QI/qzAgCgugIbCxcutA76n93/1KtXz/bX/9gAAAAAAKguups9kcqTFSGxehaU9prfuPnvfzfr1i32PprIXrPGarTSPpvo5tc7+m5KW68MgGRcZ0WOEX08Terre1PTbPVDUSBGPVGUMRPdsDvRY7W6HHqoWUGBl52hQIafdaFHPVfj9ZUrS9ZX53cNAKjzKhzY6Nixo+28887Wq1cv+8Mf/uAetQ4AAAAAgBpFd9/Pnu1NQJeWtbHrrt5EtLIr/Ebcsny518hbr8dzflGJHzVqLo3u5tc2//53YoIviaa77fVZRIvOZkkUNVJXeafwrI3vv/cew0tcRfOzAqKvtazr1Pcenmnz44/eeCjrPF9+6V2PGs4PGVKyfu5cqzSNs9de8xpxh2dtqLF3eff3M4TCRe/vj2etD7tp1WUN/fxz5DhVWStlciiIoeWSS7z1ahT+4IPe9frPAQCoZhXusfHLL7/YxIkTLScnx26++Wbr1KmTC3QMGjTIHnrooaq5SgAAAAAAKko9HXSH+HXXlX7neL9+3uNtt0W+PmmS99i/f+XP3727F9y45RZvwjqa7nYXlT46/nizl182++ij0q/Vn+iPFWRQ+SPdQR9dBikR9B503C++KFmn3psvvGBVorDQ7P77Iyfd9VwBIH2mpVFwSCWy/b4QvnvuKX2fu++OfH7nnd7jsceWvo+fjRCefaCfb7/dKk3jUO/73nsjM0P86ynP/u+/b7ZgQeT4mjIlcjsFLhSsuOOOyOt/+GHvOw4f7yqh9fvfm/3zn17prfCMDZWn0jE0NlSiCgCAmp6x0bZtWxfE0CI//PCDTZgwwaZMmWJPP/20nXnmmVVxnQAAAAAAVMwRR5gNHuxNwOpu9mOO8e7G193nem3UKK9fgHpgPPCAFzDo1cubHNbd+Ao2aLvKUsBCNwBqkvx3vzMbOlR/VHsli15/3ZuIVzBDbrjBbM4c7/zDh3vZIwoeTJ3q9TFQvw+Vs9Kk+k03eZPQWVlmRx5plpvrBRl0/MmTE99A/JRTvJJLf/6z2ejRZps2eRPw6nvxySeWcOqxofeoPhc6xzPPeI3Y9R1lZJS9r+YkbrzRe1QjdgU5/GyPWJSlcNxx3thQyaUnn/SavWtclEalpzShf/HF3nep71GN6uPpH6HG8T17es259b733tvs+efLH6gaO9bsiSe89zFmjBcE0+elDI3wgJSCQ5dd5gX7tK3eu7I3FPxRECOsr+q2IIY+T/VD6dLFW6fxph4d2q8mNKsHANRJFQ5sbNq0yd5++21744033PLpp59a586dbdSoUa40FQAAAAAANYYm+vfd17sjXaV0NEGrCe9DDinZRsEHleV59FEvQKDG4Zr8veaa+M+vv5M1YT5+vNldd3mZGzq+Gj2ffXbJdgp4fPCB2VVXeXfZq5m41ikoUq+et432u+8+s4kTzYYN8+7oV4BEE81VqXlz73O58EJvAl2lm3QNChZVRWBDJaUUWDrvPK/kUcuW3md31lk73lcNvZWpMG2a2bPPep/fv/5V+mekoIn2UUAhPd0LdqknSlkUXFFASkEefQ7KbFDQxw+UVTYIpkbk55/vBVdUdkxBh1tvNdtvvx3vr6wJjQV9ZgpE6DsbMcILEmmshFNDcAU49JlecIFXpk3BNAXXogNHfmBD/73oGsPXK7ARq78GAADVICUUqljnpszMTGvatKnL2FAg47DDDnPPUbr169db48aNbd26ddZId3IkQXFxsa1YscJyc3MtNfyXEdQZjAEI4wCMATAGUBPGQU34/RhAKRQs0QS/AjFXXln951cgaNWqHfcbiZcm95W1oCCIylcBAIDanbHRr18/l7GhslPLli1ziwIc6rUBAAAAAAACTOWvhMl+AABQg1X49qzp06fbqlWrbNasWXbwwQfbnDlzXNaG33sDAAAAAAAEkMo3nXuuVwYpnt4iAAAANS1jw9elSxcrLCy0rVu3Wn5+vs2ePdueeeYZ10QcAAAAAAAEjPpnKKihfiRqDg0AAFBbAhuTJk1yTcNVjiovL8+6du1qhx9+uA0fPtxlbgAAAAAAgABauDDZV2D2xhvVcx712NACAADqRmDjn//8p/Xq1WtbIENN/wAAAAAAAAAAAGpkYOPDDz+smisBAAAAAAAAAABIdPNweeutt+yvf/2rax6+ePFit+6JJ55w5akAAAAAAAAAAABqTGDjueees759+1pOTo59+umntmXLFrd+3bp1dsMNN1TFNQIAAAAAAAAAAFQusPG3v/3N7rvvPnvwwQctIyNj2/qePXvaJ598UtHDAQAAAAAAAAAAVF1g47vvvrPDDz98u/VqIr527VqrKmvWrLFBgwZZo0aNrEmTJjZs2DDbsGFDmfvk5+fbyJEjrXnz5tagQQMbOHCgLV++PGKbRYsWWf/+/a1evXqWm5trl1xyiRUWFkZso6yUK664wnbddVfLysqy9u3b2yOPPFIl7xMAAAAAAAAAACSweXirVq3sxx9/dJP74dRfo0OHDlZVFNRYunSpzZ071woKCmzo0KE2fPhwe+qpp0rd54ILLrCZM2fa1KlTXeBl1KhRdsIJJ9g777zjXi8qKnJBDb2nd9991x1/yJAhLhMlvKzWX/7yFxcQefjhh61jx45uu+Li4ip7rwAAAAAAAAAAIEGBjbPOOsvGjBnjMhZSUlJsyZIl9t5779nFF19sV111lVWFb775xmbNmmUffvih9ejRw6278847rV+/fnbLLbdYmzZttttHPT8UiFDg48gjj3TrJk+ebHvttZe9//77dtBBB9mcOXPs66+/tldffdVatmxp3bp1s/Hjx9ull15q1157rWVmZrrzvvnmm7Zw4UJr1qyZO050UAcAAAAAAAAAANTQUlTjxo2zU0891Y466ihXCkplqc4880w7++yz7bzzzquSi1TgROWn/KCG9O7d21JTU+2DDz6Iuc/HH3/sMju0na9z587Wrl07dzz/uF26dHFBDZ8ao69fv96++uor9/yll15y57355putbdu21qlTJxfE2bx5c5W8VwAAAAAAAAAAkMCMDWVpqN+EelGoJJWCG3vvvbfrYaHJ/pycHEu0ZcuWuf4X4dLT010GhV4rbR9lXCggEk5BDH8fPYYHNfzX/ddEmRoqs5WdnW0vvPCCrVq1ys4991xbvXq1ywCJRT05tPgUKBGVr0pWCSudNxQKUUKrDmMMQBgHYAyAMYCaMA4YfwAAAACqNbDhU9BAAQ3RJP6kSZNcVkNpgYbSsj9uuummHZahSib90aVgzpQpU1yfDtF7PfHEE+2ee+6JGciZOHGiXXfdddutX7lypWtonqz3ofJc+gNWmS6oexgDEMYBGANgDKAmjIO8vLxqPycAAACAOhjYUPBCfSfUvFtBjbFjx9rxxx/vshaUwZGWluaadVfERRddZKeffnqZ26ghuZp7r1ixImJ9YWGhrVmzxr0Wi9Zv3brV1q5dG5G1oSbg/j56XLBgQcR+et1/TVq3bu1KUPlBDVGfDv0R+Ouvv9oee+yx3bkvu+wyu/DCCyMyNnbZZRdr0aKFNWrUyJIZoNE1MIlRNzEGIIwDMAbAGEBNGAfKhgYAAACAKg9sXH311Xb//fe7nhXvvvuunXTSSTZ06FDXiFsZDHqu4EZF6A8pLTty8MEHuwCF+mZ0797drZs3b577g+zAAw+MuY+2y8jIsNdee80GDhzo1n333Xe2aNEidzz/uBMmTHBBE7/UlQI3Cj742Sg9e/a0qVOnupJbKrcl33//vfsDcOedd4557qysLLdE0z7JnEDQH6/JvgYkF2MAwjgAYwCMASR7HDD2AAAAAMSj3H9RaHL/8ccft2nTptmcOXOsqKjIZU18/vnndsopp1Q4qFERypA45phj7KyzznIZFu+8846NGjXKnbdNmzZum8WLF7vm4H4GhjIshg0b5jInXn/9dRcUUSBGwYyDDjrIbdOnTx8XwBg8eLB7H7Nnz7Yrr7zSRo4cuS0woUbpzZs3d/t+/fXXNn/+fNdf5IwzzqiSfiIAAAAAAAAAACABgQ2VXfKzJfbZZx838a/SU7rTqzqox4UCF0cddZT169fPDj30UHvggQe2vV5QUOAyMjZt2rRt3T/+8Q/74x//6DI2Dj/8cFde6vnnn9/2uoIxM2bMcI8KePz1r3+1IUOG2PXXX79tG2VpKItDGSM9evSwQYMG2YABA+yOO+6olvcNAAAAAAAAAABKpITULKIcNPmvxuB+6aiGDRvaF198Ybvttlt5dq/T1GNDGSRq0JjMHht+yS1S/+smxgCEcQDGABgDqAnjoCb8fgwAAACgDvTYUPxDjb79Ek35+fk2YsQIq1+/fsR24RkRAAAAAAAAAAAASQlsnHbaaRHPVbYJAAAAAAAAAACgRgY2Jk+eXLVXAgAAAAAAAAAAsAMUVgYAAAAAAAAAAIFBYAMAAAAAAAAAAAQGgQ0AAAAAAAAAABAYBDYAAAAAAAAAAEBgENgAAAAAAAAAAACBQWADAAAAAAAAAAAEBoENAAAAAAAAAAAQGAQ2AAAAAAAAAABAYBDYAAAAAAAAAAAAgUFgAwAAAAAAAAAABAaBDQAAAAAAAAAAEBgENgAAAAAAAAAAQGAQ2AAAAAAAAAAAAIFBYAMAAAAAAAAAAAQGgQ0AAAAAAAAAABAYBDYAAAAAAAAAAEBgENgAAAAAAAAAAACBQWADAAAAAAAAAAAEBoENAAAAAAAAAAAQGAQ2AAAAAAAAAABAYBDYAAAAAAAAAAAAgUFgAwAAAAAAAAAABAaBDQAAAAAAAAAAEBgENgAAAAAAAAAAQGAQ2AAAAAAAAAAAAIFBYAMAAAAAAAAAAAQGgQ0AAAAAAAAAABAYBDYAAAAAAAAAAEBgENgAAAAAAAAAAACBQWADAAAAAAAAAAAEBoENAAAAAAAAAAAQGAQ2AAAAAAAAAABAYBDYAAAAAAAAAAAAgUFgAwAAAAAAAAAABAaBDQAAAAAAAAAAEBgENgAAAAAAAAAAQGAQ2AAAAAAAAAAAAIFBYAMAAAAAAAAAAAQGgQ0AAAAAAAAAABAYBDYAAAAAAAAAAEBgENgAAAAAAAAAAACBQWADAAAAAAAAAAAEBoENAAAAAAAAAAAQGAQ2AAAAAAAAAABAYBDYAAAAAAAgyP7zH7OUlJLljTeSfUUAAABVisAGAAAAAKDm0iR9+KS9lsxMs8aNzTp0MOvd2+y668x++SWx57322pLztW9vSVNXgxa//Wb23nuR64qKzE4/3ezkk83eeqv8x3r00e3HUKxF33m4LVvMmjeP3KZHj/KPVZ23tO8x+lxljT8t2j+axqX/+h/+EPmansd6j9nZZu3amf3pT2YvvBD73KXtG73EuiYAAKpJenWdCAAAAACAhCgo8Jb1681+/tnstdfMxo83u+oqb0mtY/fwNWtm9ve/lzzffXcLNAUw2rb1vmMFrFq1MisuNhsyxOypp7wJ/c6dq/46XnrJbM2ayHUff2z273+b7bOPBZKCNfpMtej9XX652YQJyb4qAAAqjMAGAAAAACA4dLe+7ppft87sk0/MZs/2JsK16C73ZcvM7r3X6pRGjcwuvthqjbQ0s27dvIyNhx4yu/JKs1GjvKCGgjizZpm1aFH5448YETv4c8ghkc/DMy6i199yiwVG06ZeAKOw0Oz7782mTDHbutV77aabzC66yPtcy9o3ltL2AQCgGhDYAAAAAAAExzHHeOWIfN98Y9a/v5e5Iffd55XZ0XbhPv/c7Pbbzd5802zJEm/yfI89zE46yWzMGLP69UvKCR1xROS+//2vV3rHN3ly5DW8/LI3Ab9ggdnq1d6x9tvPbNgws1NPjdzX9+uvZnfeaTZnjtlPP3kTzbm5ZvvvbzZypNnRR3uZCTp3uPBr69XLu16VBNptt5L1r7++fWmi554ze+QRL+NAWQi6xr32Mhs40Oycc8zq1YvcPvr9KoPihhvMPvzQe+3QQ73J/d/9LnI/fS6PPeb9vOuulS9XpACWAhuTJnkT8gpWZWR4WQZ77lm5Y4YfO/rzibZ0qRc083Xq5AUF5MknzW680Sw9PZiBL40zBTREAUG9r4MOKt++AADUEHUsPxcAAAAAUKtocv6ZZyLX/eMfkc81Ka4sD03QL1xolp9vtnGj2WefmV1xhdkBB3iZHhXll0c67jhvwl3HUPmktWu94MJf/+pNomvyONwrr5jtvbfZzTd715CXV1Ii6MUXzWbOtITRuXUNJ57onXf58pJrVOBAk9b6bDSRXxoFbfr29YIo+tw2bPCyJhRYWbnSqsSgQV4vFfXaUA8Vue02s549rVo88UTJ96a+FAoK+fQZ/utfFlgKUoXbaadkXQkAAJUWkNsLAAAAAAAoxe9/b9a1q5eVIfPne5PSysp4912vjJGCEKI705XNoWCCMgtWrTL7+msvQKHsCZUoUr8K/Tx3buxyPDqfKDChCXBRFoOyH3Qdyh7RegUQpk71yir5+ysDQ1kimzaV7KfAiLZRkGDevJLzKOiijAdlSsQqo7TLLjv+bLTvs8+WPNf779PHy3TRtYl+ViAh/Nzh3nnH62lxwgleIEYBElF2ysMPm40bZwmnyXZ9TiqbJP/3f2bnnpuYYysQ9tFH268fPtzLUBA/60T69fMCKgqi6bPyy1ENGGCB4mdnhAdplCHUsWPp+6iPTayyWxp7CpgBAJAkBDYAAAAAAMGn8kR+YEMZGSq3pD4MmpT1gxoqP6RG435zcU3MKltDFMT44guzfff1shiUleAHNmKV49Exb7215LmalvuZBaJAwNix3s8qp6TJf533jjtKghp+WSOVqwo/7qJF3s9nnbV9YKM8ZZTCj6UsB9/BB5u99ZYX8JFLL/WCM6IMEwUtFGCJNYmtMlsNG5ZMhn/6qfezSlNVBWWGqEl3+PNEUbmyWJTVou9a71XBLp+CKv7j1Vd7P8+Y4QV2mje3Gi+6lFp4gM4PbpVGGTOXXLL9emXrENgAACQRpagAAAAAAMEXCpWebeBTKSVN6muSV4sf1PApu6O8vvvOy/bwXX99yXG1+EEN0QS435/h7bdL1isDIDyoIQp+qLdGIugaFeDxqTSWH9SQ006L3F6lqWIZPLgkqOH3mwif+A6nTAZ9F1oq219D+6pXhx+o8vuYhAc6qlJ403C9b/VwkVNOKVmvnih+NkkQqc/G+PFeHxQAAAKIwAYAAAAAIPj8wIHfE8G/kz58Yn9HKtIvoiLHDT92+H7hDb+rQvQ1tmxZ9vPoIIUvOtCSlVXys58Nk0jKUJk2rSQTRsEFBTvCg0XxUHaKH3wJX/Q+1evkn/8s2VZlwnJyvJ/VbL5799gBkERTo/RwykKKtnlzyc/qR1IalVJTeTVlXvjf+YoVXsCmtPJjPgU+Yn1WChICAJBElKICAAAAAASb+iWE392vMjl+ualmzbxJXDn0ULM//an04xxySPnPqeOGU/bDPvuUvr0fHAjfT704qlL0NarpdVnPNQFenkn2WGWNEuX9982uvdb7WT02lAmjUljqf6GG3Wparh4pVWX6dK+xuk9ZGaVlZqgc15dfmnXpkvjrUBm1cBorKm/mU6m08EBc9Pbhwkup6XNUuTGV9lLPDfUtUSZMOtNDAIBg4f9cAAAAAIDgUrml8BJBcuGFkcEKTVbLsmWRDaLD73xXr4HwwEb4ZH54T4zwnh7KClGZKf8Y0X04REEVlcPyG30ruKIeDqJG1E8/HXn9uhv+l1/M2rXb/jpKu5bS6BoV3PAzN9TP4+yzS8pRhTfIrmhgpzQqIeUfV3f7V6QclSbrVS6rsNCsTZuSXhjqNaKAxvPPlwSpqkpFszAmT/Z6qCTagQdGPtc51FvFzx6ZMCGy/Fr09qVRo3CNU78fjP77UeAmuiwZAAA1HIENAAAAAEBwaIJbvS3Wr/fumNdzTYT7Ro4069On5PlFF5m9+KI3Cfzjj15WxQkneCV51q3z7rh/803vDvYhQ0r2a9u25GfdGT90qNnee3vZCjqHJpgVQLniCm+bZ581W7jQ7OijvdJJCqIok+SDD7xgxp//7G03erTZvfeWlBFSj41nnvHuolcpKJX40QS23/Rbd+IruFFQ4D3X+ZSdonXarkeP0j8rZa1ccIFXzsnvoaFr0efz7bfeNfuOOMKsa1dLKpVK+ukn72d9RuEZJ4884n1nCnxUlcWLzebMKXmusfK738XOKlFDblFQQA3YK5rx8MADXgPyWDRu9F0o0OT3fXn1VS/Ypb4sv/4ame2jQF1FPpcxY7zG9wokyY03en1U/CyncPrv7JZbYh/n2GNjfz4AAFQDAhsAAAAAgOBQEEBLNE0sX3ON2eWXR67XRP5dd3mTuQqAKBvi9tt3fB6VO6pXryRDIvxOfmUlKLAxbpwXIHjiiZIJaS1lURaD+kcoSyMvzwu4KKPEzyoRBSzCeyf88Y9mL7zgPf/sM28R9U0oK7Ahl11m9sUXXkaKPymvJZwmy5XNkWz+NaoElXpbhGvc2Oyee6r2/Poew3uGKGOkZ8/tt1OQZdgw72dlkMycWXaJs1iWLvWWsug7OfLIkqwXBfTeeitym/r1vZ4g0WXHyqKSYyNGlAQsNIY1Jv/yl+23VbBNAadYdtqJwAYAIGloHg4AAAAACBaVUlJWhJpvH3WUV1ZHk79XXhn7rnP1EVB2h8pQderkBSwUCFEGgPpxKKMhvEeHtGpl9vLL3sS2Jo9j0bkef9yb2B440Gznnb1AhJprK4AxYICXeRHejFr69TP76itvwnjffc0aNPAyMFR+SQ2d9Xq4Bx/0SgXpemO9vx19VsrMUNBAx83N9d67AgUqX6TgyIcfeudONl2PJsv9bJXqFl6aS2W8YgU1RAGA8DFRVU3ENb41LpVRoewNBST0fWq8qK/H+ed7Qavo8VIeymQKbwKvhu3hpa0AAKjhUkIh/s9V1davX2+NGze2devWWaPoWq7VpLi42FasWGG5ubmWWtFfhFErMAYgjAMwBsAYQE0YBzXh92MANZBKIyljgn8XAADADlCKCgAAAAAAJJ8yEQAAAMqB2/QAAAAAAAAAAEBgENgAAAAAAAAAAACBQWADAAAAAAAAAAAEBoENAAAAAAAAAAAQGAQ2AAAAAAAAAABAYBDYAAAAAAAAAAAAgRGYwMaaNWts0KBB1qhRI2vSpIkNGzbMNmzYUOY++fn5NnLkSGvevLk1aNDABg4caMuXL4/YZtGiRda/f3+rV6+e5ebm2iWXXGKFhYUR20yZMsW6du3qtmndurWdccYZtnr16ip5nwAAAAAAAAAAoBYENhTU+Oqrr2zu3Lk2Y8YMmz9/vg0fPrzMfS644AJ7+eWXberUqfbmm2/akiVL7IQTTtj2elFRkQtqbN261d5991177LHH7NFHH7Wrr7562zbvvPOODRkyxAVSdH4da8GCBXbWWWdV6fsFAAAAAAAAAAABDWx88803NmvWLHvooYfswAMPtEMPPdTuvPNOe/rpp12wIpZ169bZww8/bJMmTbIjjzzSunfvbpMnT3YBjPfff99tM2fOHPv666/tySeftG7dutmxxx5r48ePt7vvvtsFO+S9996z9u3b2+jRo2233XZz5z777LNdcAMAAAAAAAAAAFSvQAQ2FFxQ+akePXpsW9e7d29LTU21Dz74IOY+H3/8sRUUFLjtfJ07d7Z27dq54/nH7dKli7Vs2XLbNn379rX169e77Aw5+OCD7ZdffrFXXnnFQqGQK2U1bdo069evXxW+YwAAAAAAAAAAEEu6BcCyZctc/4tw6enp1qxZM/daaftkZma6gEg4BTH8ffQYHtTwX/dfk549e7oeGyeffLLr2aH+GwMGDHBZHaXZsmWLW3wKlEhxcbFbkkHnVWAmWedH8jEGIIwDMAbAGEBNGAeMPwAAAACBDWyMGzfObrrpph2WoUomlaoaM2aM67uhbI6lS5e6BuMjRoxwpa5imThxol133XXbrV+5cqULjiTrj0eV59IfsMp0Qd3DGIAwDsAYAGMANWEc5OXlVfs5AQAAANQeSQ1sXHTRRXb66aeXuU2HDh2sVatWtmLFioj1ypxYs2aNey0WrVefjLVr10ZkbaiUlL+PHqN7Zeh1/zU/SKGsDQUzZN9997X69evbYYcdZn/729+sdevW2537sssuswsvvDAiY2OXXXaxFi1aWKNGjSxZf7ympKS4a2ASo25iDEAYB2AMgDGAmjAOsrOzq/2cAAAAAGqPpAY29IeUlh1RnwsFKNQ3Q03AZd68ee4PMjUTj0XbZWRk2GuvvWYDBw5067777jtbtGiRO55/3AkTJrigiV/qau7cuS74sPfee7vnmzZtcmWvwqWlpblH3eEWS1ZWllui6Y/GZE4g6I/XZF8DkosxAGEcgDEAxgCSPQ4YewAAAADiEYi/KPbaay875phj7KyzznIZFu+8846NGjXKTjnlFGvTpo3bZvHixa45uJ+B0bhxYxs2bJjLnHj99dddUGTo0KEumHHQQQe5bfr06eMCGIMHD7bPP//cZs+ebVdeeaWNHDlyW2BC/TSef/55u/fee23hwoXu3KNHj7YDDjhg27kBAAAAAAAAAED1CETzcFEDbwUzjjrqKHeHl7Iw7rjjjm2vFxQUuIwMZVj4/vGPf2zbVs281SPjnnvuici8mDFjhp1zzjku4KESU6eddppdf/3127ZRqSzVAL7rrrtc6SyVtTryyCN32BsEAAAAAAAAAAAkXkqotHpKSBj12FAGiRo0JrPHhl9yi9T/uokxAGEcgDEAxgBqwjioCb8fAwAAAAgu/poFAAAAAAAAAACBQWADAAAAAAAAAAAEBoENAAAAAAAAAAAQGAQ2AAAAAAAAAABAYBDYAAAAAAAAAAAAgUFgo45Y+OpCe+bwZ9wjAAAAAAAAAABBRWCjDgiFQjbvinm29oe17lHPAQAAAAAAAAAIovRkXwCq3tyL59rSj5a6n/U4Y8QMa3tAW8tqlBVzyWyQaalpxLwAAAAAAAAAADUPgY1aTtkZnz32WcS6Tx74xC1lyaifUWrgI2YwpGFmzPXpWQwxAAAAAAAAAEDiMOtcy63+frVtXr25wvsVbCxwy4alG+I6f1pmWunBkEaZltWwfIETBVpSUlLiuhYAAAAAAAAAQPAR2Kjlmndqbi27trQVX66wUHHIUlJTrEn7JnbIpYfY1ryttmX9lm3L1vWRz7fklfxslWzLUbS1yDat2uSWuKRYZLCjYVSApDyZJf/bJzWdMlsAAAAAAAAAEFQENmo5ZTn0vqm3TTlminuu4Ea/e/pZx74dy30M7VOwqSAy6FHGEh0w8Zf8dflWXFBcuTcSMtuybotb4pWek56YMlvZ6WSRAAAAAAAAAEA1I7BRB+zeZ3dr3aO1axyuRz2vCGV5qKG4loZtGsZ1LYVbCiscEIm1qExWpa9hc6FbNi7fGNd7UeZHIsps6XPVZwwAAAAAAAAA2DECG3WAsgqOnHCkzRw10z0mM8tAzcTTW6Rb/Rb14zpOcVFxSSAkrGRWqUGTMspshYoqV2eruLDYNq/Z7JZ4RWSFRAVEylVq63/7qKcJAAAAAAAAANRmBDbqiA69O9jJ80+23Nxcqw1S01Itu0m2W+IRCoVc9ka8Zba0FOYXVvo6dFwteYvz4no/aVllNGtvmGlF6UXWtFVTy26cXWaZrYx6NGsHAAAAAAAAUDMR2ECdpsl7TeJradCqQVzHUqP0WNkjFSmx5W9f6WvYUmSbVm5ySzxUGishZbYaZrogFAAAAAAAAAAkCoENIEFUBqpe83puiYeatW/dsLVcJbbKLLO1bosrl1XZa8hfm++WeGXUz4ivzNb/9lM2ClkkAAAAAAAAAAhsADVMeLaEta38cVRmSxkcfsBj89rNtnzRcstJzbGCDQUVyiwp2FT5Zu1q9K5lw9IN8ZUfyyi9WXtp2SIx19enWTsAAAAAAAAQZAQ2gFpK2Q3p2eluqZ9b34qLiy1t5zTXZyU1tWLloZT5UVoGSUVLbVnlerVbcUGxbV692S1xSbFSS2lVtMxWWgbN2gEAAAAAAIDqRmADwA6lpqdaTtMct8RDWSTK3oi7zNb6LS4bpXIXYSVBljil56THLLFV0TJbOg5ltgAAAAAAAIDyIbABoNpo8j6zQaZbGrZuGNexCrcUljtbpKzt1M+k0tewudAtG5dvjOu9pKSlJKbMVgOatQMAAAAAAKD2I7ABIJDSs9LdUm+n+Jq1FxcVe83aE1BmK1RUuTpb2i//t3y3xEvBjbICIloKUguseevmlt0ku9Rt0zIpswUAAAAAAICaicAGgDpNGQ7ZjbPdEm+ZLWVvJKLMlo5TWQrSaMlbkhfX+0nLSosol1XhMlv/2yejfgZltgAAAAAAAJBQBDYAIAE0eZ9RL8MtDVo2iOtYRQVF5c8WyYsRJAl7rbLN2tXDZNPKTW6JR0pqSqmlsypSZkuBEvV6AQAAAAAAAAhsAEANk5aRZjnNctwSj1BxyLZujAx65K/NtxW/rrCclJxSS3DFWooLiit9DVvWbXFLvBQ0qnBAJFaZraw0skgAAAAAAAACjMAGANRSypZwJaEaZpm19dYVFxdbgxUNLDc311JTU8tdZksZHJUqsxW1T8HGgkq/n4JNBW7ZsGyDxSM1IzUhZbbUz0SfMQAAAAAAAKoXgQ0AQJmU3ZCene6W+i3qx3Ws4sLSm7XH6jlSapktNWsvrlydLWWfbF692S3xSkiZLWWRZNCsHQAAAAAAoLwIbAAAqo36ZGQ3yXZLPJRFouyN7bJFytubJGxRNkpl6Xxa8hbH16xdQaNElNlKz0mnzBYAAAAAAKj1CGwAAAJHk/eZ9TPd0rB1w7iOVbS1kmW2okptKcBRWYX5hW7ZuGJjXO8lJS1lh2W2FCgpSCmw5m2auwBTzDJbDTMtNY1m7QAAAAAAoGYisAEAqNPSMtOsXvN6bom7WXt5G7LnlV5mK39dvoWKKldmS/vl/5bvlnhl1C+9WXtFskrSs/hVAwAAAAAAJBazDQAAJKpZ+/8m8+Mts6XsjUSU2SrcXFjp61Cjdy0blm6IO3CUiDJbCrRQZgsAAAAAAAiBDQAAahBN3mfkZLilQcsGcTdrjy6zlb8231b8usKyLXu7DJOILJKo/SxU+VJfm1ZtcktcUixmia3wMls7XP63r3q9AAAAAACA4CKwAQBALaUJ/JymOW7xFRcXW6MVjSw3N9dSU1PLXWYrVrP2WCW2YvYiCSuzVVxQXLk3EzLbsm6LW+KlJusJKbOVTbN2AAAAAACSgcAGAADYYZmtzAaZbmnYJr5m7YVbElNmS2WyKn0NmwvdsnH5xrgDR4kos6XPVZ8xAAAAAAAoHwIbAACg2qiZeHqLdKvfon5cxykuKi5/s/YdlNmqbLN2lfravGazW+LlAiExymyVq9RW2H7qaQIAAAAAQG1HYAMAAAROalqqZTfOdkvczdo3F8ZdZss1a8+vfLN2Za1oyVuSF9f7ScsqvVl7eDbJ1pSt1rx1c8tukh27WXs9mrUDAAAAAGouAhsAAKBuN2uvl+GWBq3ia9auRunR2SCVKbOlfSp9DVuKbNPKTW6Jh0pjJaTMVsNMF4QCAAAAACCRCGwAAAAkgMpA1Wtezy3xULP2rRsTUGZr3RZXLquy15C/Nt8t8cqon7FdyaxKldnKSiOLBAAAAADgENgAAACoQVy2hCb0G2aZtY2vzJYyOKIDIZvXbraVv6607JRsL6OkHGW2CjZVvlm7Gr1r2bB0Q3zlxzJKb9ZekaySzPo0awcAAACAoCOwAQAAUAspuyE9O90t9XNLmrUXFxdb0xVNLTc311JTy1cmSpkfiSizpcUq16vdiguKbfPqzW6JS4qV3qi9gmW20jJo1g4AAAAAyUBgAwAAAGVKTU+1nKY5bomHskiU/VHhMltRQRUtykap3EVYSZAlTuk56Qkps6XjVHeZrYWvLrSZo2Za/7v6W8c+Hav13AAAAAAQLwIbAAAAqBaavFcpKC0NWzeM61iFWwp3nDVSjjJbWzdUvll74eZCt2xcvjGu95KSlpKYMlsNytesXQGmeVfMs7U/rHWPux+9O/1LAAAAAAQKgQ0AAAAETnpWulvq7RRfs/biomIX3EhEma1QUeXqbGm//N/y3RIvBTd2FBBRv5OlHy112+vxpzk/Wce+ZG0AAAAACA4CGwAAAKizlOGQ3TjbLfFQFkRhfmFCymwpC6SyFKTRkrckr1zbq5H661e9brv3IWsDAAAAQHAQ2AAAAADipKBARk6GWxq0bBDXsYoKispdZqvMUlt5O27WHioO2ZIPl9jq71fbTnvuFNd1AwAAAEB1IbABAAAA1CBpGWmW0yzHLfFQ0GLrxu2DHjPPmWm/LfzNBT3U36P1/q2teafmCbt+AAAAAKhqBDYAAACAWkhlprIaZrnF2pas73d3P5tyzJRt/T2OGH8EZagAAAAABEpqsi8AAAAAQPVRP43WPVq7n/Wo5wAAAAAQJAQ2AAAAgDpE2RlHTjjSmuzRxD2SrQEAAAAgaChFBQAAANQxHXp3sJPnn2y5ubnJvhQAAAAAqDAyNgAAAAAAAAAAQGAQ2AAAAAAAAAAAAIFBYAMAAAAAAAAAAAQGgQ0AAAAAAAAAABAYBDYAAAAAAAAAAEBgENgAAAAAAAAAAACBQWADAAAAAAAAAAAEBoENAAAAAAAAAAAQGAQ2AAAAAAAAAABAYBDYAAAAAAAAAAAAgUFgAwAAAAAAAAAABAaBDQAAAAAAAAAAEBjpyb6AuiAUCrnH9evXJ+0aiouLLS8vz7Kzsy01lXhWXcQYgDAOwBgAYwA1YRz4vxf7vycDAAAAQEUQ2KgG+qNRdtlll2RfCgAAAFCjfk9u3Lhxsi8DAAAAQMCkhLhNqlruiFuyZIk1bNjQUlJSknINuitOgZVffvnFGjVqlJRrQHIxBiCMAzAGwBhATRgH+hNEQY02bdqQOQQAAACgwsjYqAb6Y23nnXe2mkB/uDKJUbcxBiCMAzAGwBhAsscBmRoAAAAAKovbowAAAAAAAAAAQGAQ2AAAAAAAAAAAAIFBYKOOyMrKsmuuucY9om5iDEAYB2AMgDEAYRwAAAAACDKahwMAAAAAAAAAgMAgYwMAAAAAAAAAAAQGgQ0AAAAAAAAAABAYBDYAAAAAAAAAAEBgENioRe6++25r3769ZWdn24EHHmgLFiwoc/upU6da586d3fZdunSxV155pdquFckfAw8++KAddthh1rRpU7f07t17h2MGte/fAd/TTz9tKSkpdvzxx1f5NaLmjYO1a9fayJEjrXXr1q6RcKdOnfh/Qh0bA7fddpvtueeelpOTY7vssotdcMEFlp+fX23Xi8SaP3++DRgwwNq0aeP+bZ8+ffoO93njjTds//33d/8GdOzY0R599NFquVYAAAAAqAwCG7XEM888YxdeeKFdc8019sknn1jXrl2tb9++tmLFipjbv/vuu/Z///d/NmzYMPv000/dZKaWf//739V+7UjOGNAEhsbA66+/bu+9956byOrTp48tXry42q8dyRkDvv/85z928cUXu0AX6t442Lp1qx199NFuHEybNs2+++47F/hs27ZttV87kjMGnnrqKRs3bpzb/ptvvrGHH37YHePyyy+v9mtHYmzcuNF97wpwlcfPP/9s/fv3tyOOOMI+++wzO//88+3MM8+02bNnV/m1AgAAAEBlpIRCoVCl9kSNorsxf//739tdd93lnhcXF7uJ6vPOO89NVkQ7+eST3R+9M2bM2LbuoIMOsm7dutl9991XrdeO5IyBaEVFRS5zQ/sPGTKkGq4YNWEM6Hs//PDD7YwzzrC33nrL3blfnjt7UXvGgf7N//vf/27ffvutZWRkJOGKkewxMGrUKBfQeO2117atu+iii+yDDz6wt99+u1qvHYmnjI0XXnihzIy8Sy+91GbOnBlxg8spp5zi/p8wa9asarpSAAAAACg/MjZqAd1t+/HHH7tSQr7U1FT3XHfix6L14duL7uYsbXvUvjEQbdOmTVZQUGDNmjWrwitFTRsD119/veXm5rrsLdTNcfDSSy/ZwQcf7EpRtWzZ0vbZZx+74YYbXNALdWMMHHLIIW4fv1zVwoULXSmyfv36Vdt1I7n4vRAAAABA0KQn+wIQv1WrVrkJKE1IhdNz3YEby7Jly2Jur/WoG2Mg1t2aqsUdPbGB2jsGdCe2Ss6o7Ajq7jjQJPa8efNs0KBBbjL7xx9/tHPPPdcFOlWaCLV/DJx66qluv0MPPdSUyFtYWGgjRoygFFUdUtrvhevXr7fNmze73isAAAAAUJOQsQHAbrzxRtc8WqUq1GgWtV9eXp4NHjzY9VLYaaedkn05SCKVKVLWzgMPPGDdu3d3pQqvuOIKyhLWIeq5pCyde+65x/XkeP75511ZovHjxyf70gAAAAAAiImMjVpAk5JpaWm2fPnyiPV63qpVq5j7aH1FtkftGwO+W265xQU2Xn31Vdt3332r+EpRU8bATz/95JpFDxgwIGKCW9LT010D6d13370arhzJ/regdevWrreG9vPttdde7g5ulTXKzMys8utGcsfAVVdd5QKdahYtXbp0cX24hg8f7oJcKmWF2q203wsbNWpEtgYAAACAGom/VGsBTTrpLtvwpp+aoNRz1U2PRevDt5e5c+eWuj1q3xiQm2++2d2Rq8agPXr0qKarRU0YA507d7Yvv/zSlaHyl+OOO86OOOII97MaDaNu/FvQs2dPV37KD2zJ999/7wIeBDXqxhhQj6Xo4IUf6FJpKtR+/F4IAAAAIGjI2KglLrzwQjvttNPc5PQBBxxgt912m7vbcujQoe71IUOGWNu2bW3ixInu+ZgxY6xXr1526623Wv/+/V0Zoo8++siVIkHdGAM33XSTXX311fbUU09Z+/btt/VXadCggVtQu8eASo6pSXS4Jk2auMfo9ajd/xacc845dtddd7n/L5x33nn2ww8/uLJEo0ePTvI7QXWNAWVuTZo0yfbbbz878MADXaBLWRxaH57Jg+DYsGGD+x59P//8swtaN2vWzNq1a2eXXXaZLV682B5//HH3unqq6N+BsWPH2hlnnOH67jz77LOuJBkAAAAA1EQENmoJ1URfuXKlm6jWBHW3bt3cXfh+I8hFixZF3I15yCGHuAntK6+80jUH3WOPPWz69OlMaNahMXDvvfe6MjMnnnhixHHULPjaa6+t9utH9Y8B1E4VHQfKzpk9e7ZdcMEFrhydJrwV5Lj00kuT+C5QnWNAvwukpKS4R012t2jRwgU1JkyYkMR3gXjoZhVl4IUHu0QBr0cffdSWLl3qxoFvt912c0EM/Ttw++23284772wPPfSQ9e3bNynXDwAAAAA7khKixgAAAAAAAAAAAAgIbt0FAAAAAAAAAACBQWADAAAAAAAAAAAEBoENAAAAAAAAAAAQGAQ2AAAAAAAAAABAYBDYAAAAAAAAAAAAgUFgAwAAAAAAAAAABAaBDQAAAAAAAAAAEBgENgAAAAAAAAAAQGAQ2AAAIEHeeOMNS0lJsbVr1yb7UgAAAAAAAGotAhsAgIQ4/fTT3aR+9PLjjz9aELRv395uu+22ZF8GAAAAAAAAdiB9RxsAAFBexxxzjE2ePDliXYsWLbbbbuvWrZaZmVmNVwYAAAAAAIDagowNAEDCZGVlWatWrSKWtLQ0+8Mf/mCjRo2y888/33baaSfr27ev237SpEnWpUsXq1+/vu2yyy527rnn2oYNG7Yd79FHH7UmTZrYjBkzbM8997R69erZiSeeaJs2bbLHHnvMZVk0bdrURo8ebUVFRdv227Jli1188cXWtm1bd+wDDzzQlYmqCGWbPPTQQ/bnP//ZnXePPfawl156KWKbV155xTp16mQ5OTl2xBFH2H/+85/tjvP222/bYYcd5rbRe9S1bty40b32+OOPW4MGDeyHH37Ytr0+g86dO7v3CAAAAAAAgO0R2AAAVAsFIpSl8c4779h9993n1qWmptodd9xhX331lXt93rx5Nnbs2Ij9NMGvbZ5++mmbNWuWC1Ao2KCggpYnnnjC7r//fps2bdq2fRREee+999w+X3zxhZ100kkumyQ8gFAe1113nf3lL39xx+jXr58NGjTI1qxZ41775Zdf7IQTTrABAwbYZ599ZmeeeaaNGzcuYv+ffvrJnXfgwIHuGM8884wLdOj6ZMiQIduOW1hYaDNnznTBlClTprhgCgAAAAAAALaXEgqFQjHWAwBQ4R4bTz75pGVnZ29bd+yxx9rUqVNdxsb69evtk08+KfMYCk6MGDHCVq1atS1jY+jQoa5Px+677+7W6XUFM5YvX+6yHUTBA2VvKGCyaNEi69Chg3ts06bNtmP37t3bDjjgALvhhhtinlv7K6NEi5+xceWVV9r48ePdc2VZ6Hz/+te/3Pkuv/xye/HFF11QxqfAxk033WS//fabyzRRsEMZKwq8+BTY6NWrlzuePittu++++7oAyfPPP+8yOnRsAAAAAAAAxEaPDQBAwqgc07333rvtucpA+bp3777d9q+++qpNnDjRvv32Wxf4UNZCfn6+y9LwMxb06Ac1pGXLli4I4Qc1/HUrVqxwP3/55ZeuLJVKRIVTearmzZtX6P0o4BD+Xho1arTtPN98840rcRXu4IMPjnj++eefu0wNZWD4dD9BcXGx/fzzz7bXXnu5UloPP/ywK891yCGHbJf1AQAAAAAAgEgENgAACaPJ/44dO5b6Wjj1o/jjH/9o55xzjk2YMMGaNWvmshmGDRvmmov7gY2MjIyI/ZRJEWudggWiHh3Kkvj444/dY7jwYEh5lHWe8tC1nH322S4LI1q7du22/Tx//nx3rUuXLnWZHA0bNqzQdQIAAAAAANQlBDYAAEmhwIOCBLfeeqvrtSHPPvts3Mfdb7/9XMaGMivUtLuqKNsiupn4+++/H/F8//33t6+//rrUYI+8++67rnzVyy+/bJdeeqnrv6F+IwAAAAAAAIiN5uEAgKTQZH9BQYHdeeedtnDhQtc3w28qHg+VoFIzbjXmVs8KlXxasGCBK3ml5tyJol4fakZ+ySWX2HfffWdPPfWU6wkSToEKBS4UrFCDcW2vvhx+8/C8vDwbPHiwy+hQPxKVrFKD8fBG6AAAAAAAAIhEYAMAkBRdu3a1SZMmuWyFffbZx03qK/iQCJMnT3aBjYsuusj23HNPO/744+3DDz+MKP8ULx3rueees+nTp7v3oqBMdGNy9eh488037fvvv3fZI8omufrqq7c1NR8zZowr0eXv16VLF/ezylctXrw4YdcKAAAAAABQm6SE1MUUAAAAAAAAAAAgAMjYAAAAAAAAAAAAgUFgAwAAAAAAAAAABAaBDQAAAAAAAAAAEBgENgAAAAAAAAAAQGAQ2AAAAAAAAAAAAIFBYAMAAAAAAAAAAAQGgQ0AAAAAAAAAABAYBDYAAAAAAAAAAEBgENgAAAAAAAAAAACBQWADAAAAAAAAAAAEBoENAAAAAAAAAAAQGAQ2AAAAAAAAAACABcX/Ay+sMlIhbcOvAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode 3 Detection Analysis:\n", + " Correct language: 'drag the ceramic bowl in a circle'\n", + " Incorrect language: 'jump up and down'\n", + " Final reward (correct): 0.4228\n", + " Final reward (incorrect): 0.4320\n", + " Difference: -0.0092\n", + " Detection: FAILURE\n" + ] + } + ], + "source": [ + "# Test success vs failure detection with visualization\n", + "def compare_correct_vs_incorrect_language(episode_idx, max_frames=32):\n", + " \"\"\"Compare rewards for correct vs incorrect language for the same episode.\"\"\"\n", + "\n", + " # Get original episode data\n", + " frames, correct_language, correct_rewards, episode_length = get_episode_data(episode_idx, max_frames)\n", + "\n", + " if correct_rewards is None:\n", + " print(f\"No data available for episode {episode_idx}\")\n", + " return\n", + "\n", + " # Generate incorrect language\n", + " incorrect_languages = [\n", + " \"kick the ball\",\n", + " \"dance in place\",\n", + " \"wave your hand\",\n", + " \"jump up and down\",\n", + " \"spin around\",\n", + " \"do nothing\",\n", + " ]\n", + " incorrect_language = incorrect_languages[episode_idx % len(incorrect_languages)]\n", + "\n", + " # Predict rewards with incorrect language\n", + " incorrect_rewards = evaluator.predict_episode_rewards(frames, incorrect_language)\n", + "\n", + " # Create comparison plot\n", + " fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(16, 10))\n", + "\n", + " time_steps = range(len(correct_rewards))\n", + "\n", + " # 1. Reward curves comparison\n", + " ax1.plot(\n", + " time_steps, correct_rewards, \"g-\", linewidth=2, marker=\"o\", markersize=4, label=\"Correct Language\"\n", + " )\n", + " ax1.plot(\n", + " time_steps, incorrect_rewards, \"r-\", linewidth=2, marker=\"s\", markersize=4, label=\"Incorrect Language\"\n", + " )\n", + " ax1.set_title(f\"Episode {episode_idx} - Reward Comparison\")\n", + " ax1.set_xlabel(\"Frame Index\")\n", + " ax1.set_ylabel(\"Predicted Reward\")\n", + " ax1.legend()\n", + " ax1.grid(True, alpha=0.3)\n", + "\n", + " # 2. Final reward comparison\n", + " final_correct = correct_rewards[-1]\n", + " final_incorrect = incorrect_rewards[-1]\n", + "\n", + " ax2.bar(\n", + " [\"Correct\\nLanguage\", \"Incorrect\\nLanguage\"],\n", + " [final_correct, final_incorrect],\n", + " color=[\"green\", \"red\"],\n", + " alpha=0.7,\n", + " )\n", + " ax2.set_title(\"Final Reward Comparison\")\n", + " ax2.set_ylabel(\"Final Reward\")\n", + "\n", + " # Add values on bars\n", + " ax2.text(0, final_correct + 0.01, f\"{final_correct:.3f}\", ha=\"center\", va=\"bottom\", fontweight=\"bold\")\n", + " ax2.text(1, final_incorrect + 0.01, f\"{final_incorrect:.3f}\", ha=\"center\", va=\"bottom\", fontweight=\"bold\")\n", + "\n", + " # 3. Reward difference over time\n", + " reward_diff = correct_rewards - incorrect_rewards\n", + " ax3.plot(time_steps, reward_diff, \"purple\", linewidth=2, marker=\"d\", markersize=4)\n", + " ax3.axhline(y=0, color=\"black\", linestyle=\"--\", alpha=0.5)\n", + " ax3.set_title(\"Reward Difference (Correct - Incorrect)\")\n", + " ax3.set_xlabel(\"Frame Index\")\n", + " ax3.set_ylabel(\"Reward Difference\")\n", + " ax3.grid(True, alpha=0.3)\n", + "\n", + " # 4. Language descriptions\n", + " ax4.axis(\"off\")\n", + " ax4.text(0.1, 0.8, \"Language Conditions:\", fontsize=14, fontweight=\"bold\")\n", + " ax4.text(0.1, 0.6, f'Correct: \"{correct_language}\"', fontsize=12, color=\"green\")\n", + " ax4.text(0.1, 0.4, f'Incorrect: \"{incorrect_language}\"', fontsize=12, color=\"red\")\n", + "\n", + " detection_success = \"✓ SUCCESS\" if final_correct > final_incorrect else \"✗ FAILURE\"\n", + " color = \"green\" if final_correct > final_incorrect else \"red\"\n", + " ax4.text(0.1, 0.2, f\"Detection: {detection_success}\", fontsize=14, fontweight=\"bold\", color=color)\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + " # Print statistics\n", + " print(f\"Episode {episode_idx} Detection Analysis:\")\n", + " print(f\" Correct language: '{correct_language}'\")\n", + " print(f\" Incorrect language: '{incorrect_language}'\")\n", + " print(f\" Final reward (correct): {final_correct:.4f}\")\n", + " print(f\" Final reward (incorrect): {final_incorrect:.4f}\")\n", + " print(f\" Difference: {final_correct - final_incorrect:.4f}\")\n", + " print(f\" Detection: {'SUCCESS' if final_correct > final_incorrect else 'FAILURE'}\")\n", + "\n", + "\n", + "# Test detection on multiple episodes\n", + "detection_episodes = [0, 1, 2, 3] # Change as needed\n", + "\n", + "for episode_idx in detection_episodes:\n", + " print(f\"\\n{'=' * 50}\")\n", + " print(f\"DETECTION TEST - EPISODE {episode_idx}\")\n", + " print(\"=\" * 50)\n", + " compare_correct_vs_incorrect_language(episode_idx)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "lerobot", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/src/lerobot/policies/factory.py b/src/lerobot/policies/factory.py index dab238c20..94e1b6ada 100644 --- a/src/lerobot/policies/factory.py +++ b/src/lerobot/policies/factory.py @@ -34,6 +34,7 @@ from lerobot.policies.diffusion.configuration_diffusion import DiffusionConfig from lerobot.policies.pi0.configuration_pi0 import PI0Config from lerobot.policies.pi0fast.configuration_pi0fast import PI0FASTConfig from lerobot.policies.pretrained import PreTrainedPolicy +from lerobot.policies.rlearn.configuration_rlearn import RLearNConfig from lerobot.policies.sac.configuration_sac import SACConfig from lerobot.policies.sac.reward_model.configuration_classifier import RewardClassifierConfig from lerobot.policies.smolvla.configuration_smolvla import SmolVLAConfig @@ -80,6 +81,10 @@ def get_policy_class(name: str) -> type[PreTrainedPolicy]: from lerobot.policies.smolvla.modeling_smolvla import SmolVLAPolicy return SmolVLAPolicy + elif name == "rlearn": + from lerobot.policies.rlearn.modeling_rlearn import RLearNPolicy + + return RLearNPolicy else: raise NotImplementedError(f"Policy with name {name} is not implemented.") @@ -103,6 +108,8 @@ def make_policy_config(policy_type: str, **kwargs) -> PreTrainedConfig: return SmolVLAConfig(**kwargs) elif policy_type == "reward_classifier": return RewardClassifierConfig(**kwargs) + elif policy_type == "rlearn": + return RLearNConfig(**kwargs) else: raise ValueError(f"Policy type '{policy_type}' is not available.") @@ -220,6 +227,13 @@ def make_processor( cast(SmolVLAConfig, policy_cfg), dataset_stats=kwargs.get("dataset_stats") ) + elif policy_cfg.type == "rlearn": + from lerobot.policies.rlearn.processor_rlearn import make_rlearn_processor + + processors = make_rlearn_processor( + cast(RLearNConfig, policy_cfg), dataset_stats=kwargs.get("dataset_stats") + ) + else: raise NotImplementedError(f"Processor for policy type '{policy_cfg.type}' is not implemented.") diff --git a/src/lerobot/policies/rlearn/configuration_rlearn.py b/src/lerobot/policies/rlearn/configuration_rlearn.py new file mode 100644 index 000000000..c267cbf12 --- /dev/null +++ b/src/lerobot/policies/rlearn/configuration_rlearn.py @@ -0,0 +1,127 @@ +#!/usr/bin/env python + +# Copyright 2025 The HuggingFace Inc. team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from dataclasses import dataclass, field + +from lerobot.configs.policies import PreTrainedConfig +from lerobot.configs.types import NormalizationMode + + +@PreTrainedConfig.register_subclass("rlearn") +@dataclass +class RLearNConfig(PreTrainedConfig): + """Configuration for a video-language conditioned reward model (RLearN). + + Inputs: + - Visual frames (one or multiple cameras). Optionally a short sequence. + - A language instruction/goal string. + + Output: + - Per-timestep reward logits or a single-step reward logit. + + Notes: + - This is the initial architecture. It uses frozen vision/text encoders + (e.g. SigLIP2) and trains a lightweight temporal aggregator + head. + """ + + # Encoders + model_name: str = "google/siglip2-large-patch16-256" + freeze_backbones: bool = True + + # Temporal aggregator + dim_model: int = 512 + n_heads: int = 8 + n_layers: int = 4 + dim_feedforward: int = 2048 + dropout: float = 0.1 + pre_norm: bool = True + use_first_frame_positional_bias: bool = True + frame_dropout_p: float = 0.0 + stride: int = 1 + + # Sequence length, amount of past frames including current one to use in the temporal model + max_seq_len: int = 16 + + # Head + use_tanh_head: bool = False # when True, bound outputs in [-1, 1] + + # Training + learning_rate: float = 5e-5 # Reduced for stability + weight_decay: float = 0.01 + loss_type: str = "composite" # Always use composite loss with spatial awareness + ranking_margin: float = 0.1 + + # Composite loss weights (with spatial awareness and ReWiND reversibility) + lambda_prog: float = 1.0 # Progress regression weight + lambda_spatial_nce: float = 0.5 # Spatial-aware InfoNCE weight + lambda_rewind: float = 0.4 # ReWiND reversible ranking weight + + # Loss hyperparameters + nce_temperature: float = 0.07 # Temperature for InfoNCE + zscore_eps: float = 1e-5 # Epsilon for z-score normalization + min_rank_gap: int = 1 # Minimum gap for temporal ranking pairs + num_ranking_pairs: int = 64 # Number of (far, near) pairs to sample for ReWiND + last_k_for_nce: int = 3 # Use last k frames for InfoNCE + mismatch_lang_prob: float = 0.2 # Probability of language mismatch augmentation + + # Value-based pairwise loss hyperparameters (for value_pairwise mode) + lambda_dir: float = 1.0 # Intra-trajectory directional ranking + lambda_text: float = 0.5 # Inter-instruction contrastive ranking + lambda_flat: float = 0.25 # Flatness under mismatch + dir_margin: float = 0.2 # Margin for directional ranking + text_margin: float = 0.2 # Margin for text contrastive ranking + flat_epsilon: float = 0.05 # Epsilon band for flatness loss + num_pairs_per_loss: int = 64 # Number of pairs to sample per loss term + use_hard_negatives: bool = True # Whether to generate hard negative instructions + + # Normalization presets + normalization_mapping: dict[str, NormalizationMode] = field( + default_factory=lambda: { + "VISUAL": NormalizationMode.MEAN_STD, + # Language is tokenized at the encoder level; no numeric normalization here. + } + ) + + def validate_features(self) -> None: + # Require at least one image feature. Language is recommended but optional (can be blank). + if not self.image_features: + raise ValueError( + "You must provide at least one image feature for RLearN (e.g. 'observation.image')." + ) + + @property + def observation_delta_indices(self) -> list | None: + # Not using delta sampling from the dataset by default. + return None + + @property + def action_delta_indices(self) -> list | None: + # Not an action chunking policy. + return None + + @property + def reward_delta_indices(self) -> list | None: + # By default we supervise every provided timestep equally. + return None + + def get_optimizer_preset(self): # type: ignore[override] + from lerobot.optim.optimizers import AdamWConfig + + return AdamWConfig(lr=self.learning_rate, weight_decay=self.weight_decay) + + def get_scheduler_preset(self): # type: ignore[override] + # No scheduler by default. + return None diff --git a/src/lerobot/policies/rlearn/evaluation.py b/src/lerobot/policies/rlearn/evaluation.py new file mode 100644 index 000000000..2f8738403 --- /dev/null +++ b/src/lerobot/policies/rlearn/evaluation.py @@ -0,0 +1,601 @@ +#!/usr/bin/env python + +# Copyright 2025 The HuggingFace Inc. team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +Evaluation metrics for RLearn (Video-Language Conditioned Reward Model). + +Key metrics: +1. VOC-S (Value-Order Correlation for Success): Spearman correlation between frame indices and predicted rewards +2. Success vs Failure Detection: Model's ability to distinguish between correct and incorrect language conditions +""" + +from __future__ import annotations + +import warnings +from typing import Any + +import numpy as np +import torch +from scipy.stats import spearmanr +from torch import Tensor +from tqdm import tqdm + +from lerobot.constants import OBS_IMAGES, OBS_LANGUAGE + + +def compute_voc_s( + predicted_rewards: list[np.ndarray], use_interquartile_mean: bool = True +) -> dict[str, float]: + """ + Compute Value-Order Correlation for Success (VOC-S). + + Measures whether per-frame rewards increase as successful execution unfolds. + For each episode, computes Spearman correlation between frame indices [1..T] + and predicted rewards [r1..rT]. + + Args: + predicted_rewards: List of reward arrays, one per episode. Each array has shape (T,) + use_interquartile_mean: If True, use IQM instead of mean for aggregation + + Returns: + Dictionary with VOC-S metrics: + - voc_s_mean: Mean Spearman correlation across episodes + - voc_s_std: Standard deviation of correlations + - voc_s_iqm: Interquartile mean (if use_interquartile_mean=True) + - num_episodes: Number of episodes evaluated + - correlations: Individual correlations per episode + """ + if not predicted_rewards: + return {"voc_s_mean": 0.0, "voc_s_std": 0.0, "voc_s_iqm": 0.0, "num_episodes": 0, "correlations": []} + + correlations = [] + + for episode_rewards in predicted_rewards: + if len(episode_rewards) < 2: + # Need at least 2 points for correlation + continue + + # Frame indices: [1, 2, ..., T] + frame_indices = np.arange(1, len(episode_rewards) + 1) + + # Compute Spearman correlation + try: + correlation, p_value = spearmanr(frame_indices, episode_rewards) + + # Handle NaN correlations (e.g., all rewards are identical) + if np.isnan(correlation): + correlation = 0.0 + + correlations.append(correlation) + + except Exception as e: + warnings.warn(f"Failed to compute correlation for episode: {e}") + correlations.append(0.0) + + if not correlations: + return {"voc_s_mean": 0.0, "voc_s_std": 0.0, "voc_s_iqm": 0.0, "num_episodes": 0, "correlations": []} + + correlations = np.array(correlations) + + # Compute statistics + voc_s_mean = float(np.mean(correlations)) + voc_s_std = float(np.std(correlations)) + + # Interquartile mean: mean of values between 25th and 75th percentiles + if use_interquartile_mean and len(correlations) >= 4: + q25, q75 = np.percentile(correlations, [25, 75]) + iqm_mask = (correlations >= q25) & (correlations <= q75) + voc_s_iqm = float(np.mean(correlations[iqm_mask])) + else: + voc_s_iqm = voc_s_mean + + return { + "voc_s_mean": voc_s_mean, + "voc_s_std": voc_s_std, + "voc_s_iqm": voc_s_iqm, + "num_episodes": len(correlations), + "correlations": correlations.tolist(), + } + + +def compute_success_failure_detection( + correct_rewards: list[np.ndarray], incorrect_rewards: list[np.ndarray], threshold_percentile: float = 50.0 +) -> dict[str, float]: + """ + Compute success vs failure detection accuracy. + + Tests the model's ability to distinguish between correct and incorrect language conditions. + For each episode, compares final reward under correct vs incorrect language instruction. + + Args: + correct_rewards: List of reward arrays for episodes with correct language + incorrect_rewards: List of reward arrays for episodes with incorrect/mismatched language + threshold_percentile: Percentile of correct rewards to use as threshold + + Returns: + Dictionary with detection metrics: + - detection_accuracy: Fraction of episodes where correct > incorrect + - mean_correct_final: Mean final reward for correct language + - mean_incorrect_final: Mean final reward for incorrect language + - separation_score: (mean_correct - mean_incorrect) / (std_correct + std_incorrect) + - num_pairs: Number of episode pairs evaluated + """ + if len(correct_rewards) != len(incorrect_rewards): + raise ValueError("Must have same number of correct and incorrect reward sequences") + + if not correct_rewards: + return { + "detection_accuracy": 0.0, + "mean_correct_final": 0.0, + "mean_incorrect_final": 0.0, + "separation_score": 0.0, + "num_pairs": 0, + } + + # Extract final rewards (last timestep of each episode) + correct_finals = [] + incorrect_finals = [] + + for correct_ep, incorrect_ep in zip(correct_rewards, incorrect_rewards, strict=False): + if len(correct_ep) > 0 and len(incorrect_ep) > 0: + correct_finals.append(correct_ep[-1]) # Final reward + incorrect_finals.append(incorrect_ep[-1]) # Final reward + + if not correct_finals: + return { + "detection_accuracy": 0.0, + "mean_correct_final": 0.0, + "mean_incorrect_final": 0.0, + "separation_score": 0.0, + "num_pairs": 0, + } + + correct_finals = np.array(correct_finals) + incorrect_finals = np.array(incorrect_finals) + + # Detection accuracy: fraction where correct > incorrect + detection_accuracy = float(np.mean(correct_finals > incorrect_finals)) + + # Statistics + mean_correct = float(np.mean(correct_finals)) + mean_incorrect = float(np.mean(incorrect_finals)) + std_correct = float(np.std(correct_finals)) + std_incorrect = float(np.std(incorrect_finals)) + + # Separation score: normalized difference (clamp to prevent extreme values) + denominator = std_correct + std_incorrect + if denominator > 1e-6: # Prevent division by very small numbers + separation_score = (mean_correct - mean_incorrect) / denominator + # Clamp to reasonable range + separation_score = np.clip(separation_score, -100.0, 100.0) + else: + separation_score = 0.0 + + return { + "detection_accuracy": detection_accuracy, + "mean_correct_final": mean_correct, + "mean_incorrect_final": mean_incorrect, + "separation_score": float(separation_score), + "num_pairs": len(correct_finals), + } + + +def generate_mismatched_languages( + original_languages: list[str], mismatch_templates: list[str] | None = None +) -> list[str]: + """ + Generate mismatched language instructions for failure detection evaluation. + + Args: + original_languages: List of original task descriptions + mismatch_templates: Custom mismatch templates. If None, uses defaults. + + Returns: + List of mismatched language instructions + """ + if mismatch_templates is None: + mismatch_templates = ["kick the ball", "walk to the red shoes", "wave", "do nothing"] + + # For each original language, pick a random mismatch + mismatched = [] + np.random.seed(42) # For reproducibility + + for i, orig_lang in enumerate(original_languages): + # Use modulo to cycle through mismatches if we have more episodes than templates + mismatch_idx = i % len(mismatch_templates) + mismatched.append(mismatch_templates[mismatch_idx]) + + return mismatched + + +class RLearnEvaluator: + """ + Comprehensive evaluator for RLearN reward models. + + Provides methods to evaluate VOC-S and success/failure detection on datasets. + """ + + def __init__(self, model, device: str = "cuda"): + """ + Args: + model: RLearN model instance + device: Device to run evaluation on + """ + self.model = model + self.device = device + self.model.eval() + + @torch.no_grad() + def predict_episode_rewards(self, frames: Tensor, language: str, batch_size: int = 16) -> np.ndarray: + """ + Predict rewards for a single episode. + + Args: + frames: Video frames tensor of shape (T, C, H, W) + language: Language instruction string + batch_size: Maximum sequence length to process at once + + Returns: + Predicted rewards array of shape (T,) + """ + T = frames.shape[0] + + # Preprocess frames to match model expectations + processed_frames = self._preprocess_frames(frames) + + # Process in chunks if episode is very long + if T <= batch_size: + # Single batch + batch = { + OBS_IMAGES: processed_frames.unsqueeze(0).to(self.device), # (1, T, C, H, W) + OBS_LANGUAGE: [language], + } + + # Use the new predict_rewards method + values = self.model.predict_rewards(batch) # (1, T') + rewards = values.squeeze(0).cpu().numpy() # (T',) + + else: + # Process in overlapping chunks to handle very long episodes + rewards = [] + stride = batch_size // 2 # 50% overlap + + for i in range(0, T, stride): + end_idx = min(i + batch_size, T) + chunk_frames = processed_frames[i:end_idx] + + batch = {OBS_IMAGES: chunk_frames.unsqueeze(0).to(self.device), OBS_LANGUAGE: [language]} + + chunk_values = self.model.predict_rewards(batch) + chunk_rewards = chunk_values.squeeze(0).cpu().numpy() + + # For overlapping chunks, only take the first half (except for the last chunk) + if i + batch_size < T: + rewards.extend(chunk_rewards[:stride]) + else: + rewards.extend(chunk_rewards) + + rewards = np.array(rewards[:T]) # Ensure exact length + + return rewards + + def _preprocess_frames(self, frames: Tensor) -> Tensor: + """ + Preprocess frames to match model expectations. + + Args: + frames: Input frames tensor of shape (T, C, H, W) + + Returns: + Preprocessed frames tensor of shape (T, C, H', W') + """ + import torch.nn.functional as F + + T, C, H, W = frames.shape + + # Expected input size for SigLIP2 is typically 256x256 + target_size = 256 + + # Resize frames if needed + if H != target_size or W != target_size: + # Resize using bilinear interpolation + frames = F.interpolate( + frames, size=(target_size, target_size), mode="bilinear", align_corners=False + ) + + # Normalize to [0, 1] if needed + if frames.dtype == torch.uint8: + frames = frames.float() / 255.0 + + # Ensure values are in [0, 1] range + frames = torch.clamp(frames, 0.0, 1.0) + + return frames + + def evaluate_voc_s( + self, dataset, num_episodes: int = 100, use_interquartile_mean: bool = True + ) -> dict[str, Any]: + """ + Evaluate VOC-S on a dataset. + + Args: + dataset: LeRobot dataset instance + num_episodes: Number of episodes to evaluate (randomly sampled) + use_interquartile_mean: Whether to compute IQM + + Returns: + VOC-S evaluation results + """ + print(f"Evaluating VOC-S on {num_episodes} episodes...") + + # Sample episodes + total_episodes = dataset.num_episodes + if num_episodes >= total_episodes: + episode_indices = list(range(total_episodes)) + else: + np.random.seed(42) + episode_indices = np.random.choice(total_episodes, num_episodes, replace=False) + + predicted_rewards = [] + + for ep_idx in tqdm(episode_indices, desc="Computing VOC-S"): + try: + # Get episode data + ep_start = dataset.episode_data_index["from"][ep_idx].item() + ep_end = dataset.episode_data_index["to"][ep_idx].item() + episode_length = ep_end - ep_start + + # Get frames and language for this episode + frames = [] + language = None + + for frame_idx in range(episode_length): + global_idx = ep_start + frame_idx + frame_data = dataset[global_idx] + + # Extract image (assuming single camera for now) + if OBS_IMAGES in frame_data: + img = frame_data[OBS_IMAGES] + else: + # Try to find image key + img_keys = [k for k in frame_data.keys() if "image" in k.lower()] + if img_keys: + img = frame_data[img_keys[0]] + else: + continue + + # Convert to tensor if needed + if isinstance(img, np.ndarray): + img = torch.from_numpy(img) + + # Ensure CHW format + if len(img.shape) == 3 and img.shape[-1] in [1, 3, 4]: + img = img.permute(2, 0, 1) # HWC -> CHW + + # Resize to expected input size (256x256 for SigLIP2) BEFORE stacking + if img.shape[-2:] != (256, 256): + import torch.nn.functional as F + + img = F.interpolate( + img.unsqueeze(0), size=(256, 256), mode="bilinear", align_corners=False + ).squeeze(0) + + # Normalize to [0, 1] if needed + if img.dtype == torch.uint8: + img = img.float() / 255.0 + + frames.append(img) + + # Get language instruction + if language is None: + if OBS_LANGUAGE in frame_data: + language = frame_data[OBS_LANGUAGE] + if isinstance(language, list): + language = language[0] + elif "task" in frame_data: + language = frame_data["task"] + else: + language = "" # Default empty language + + if not frames: + continue + + # Stack frames into video tensor + frames_tensor = torch.stack(frames) # (T, C, H, W) + + # Predict rewards + episode_rewards = self.predict_episode_rewards(frames_tensor, language) + predicted_rewards.append(episode_rewards) + + except Exception as e: + warnings.warn(f"Failed to process episode {ep_idx}: {e}") + continue + + # Compute VOC-S + voc_results = compute_voc_s(predicted_rewards, use_interquartile_mean) + + print("VOC-S Results:") + print(f" Mean correlation: {voc_results['voc_s_mean']:.4f}") + print(f" Std correlation: {voc_results['voc_s_std']:.4f}") + print(f" IQM correlation: {voc_results['voc_s_iqm']:.4f}") + print(f" Episodes evaluated: {voc_results['num_episodes']}") + + return voc_results + + def evaluate_success_failure_detection( + self, dataset, num_episodes: int = 100, mismatch_templates: list[str] | None = None + ) -> dict[str, Any]: + """ + Evaluate success vs failure detection. + + Args: + dataset: LeRobot dataset instance + num_episodes: Number of episodes to evaluate + mismatch_templates: Custom mismatch language templates + + Returns: + Success/failure detection results + """ + print(f"Evaluating success/failure detection on {num_episodes} episodes...") + + # Sample episodes + total_episodes = dataset.num_episodes + if num_episodes >= total_episodes: + episode_indices = list(range(total_episodes)) + else: + np.random.seed(42) + episode_indices = np.random.choice(total_episodes, num_episodes, replace=False) + + correct_rewards = [] + incorrect_rewards = [] + + # Get original languages + original_languages = [] + for ep_idx in episode_indices: + ep_start = dataset.episode_data_index["from"][ep_idx].item() + frame_data = dataset[ep_start] + + if OBS_LANGUAGE in frame_data: + lang = frame_data[OBS_LANGUAGE] + if isinstance(lang, list): + lang = lang[0] + elif "task" in frame_data: + lang = frame_data["task"] + else: + lang = "" + + original_languages.append(lang) + + # Generate mismatched languages + mismatched_languages = generate_mismatched_languages(original_languages, mismatch_templates) + + for i, ep_idx in enumerate(tqdm(episode_indices, desc="Computing detection metrics")): + try: + # Get episode frames (same as VOC-S evaluation) + ep_start = dataset.episode_data_index["from"][ep_idx].item() + ep_end = dataset.episode_data_index["to"][ep_idx].item() + episode_length = ep_end - ep_start + + frames = [] + for frame_idx in range(episode_length): + global_idx = ep_start + frame_idx + frame_data = dataset[global_idx] + + # Extract image + if OBS_IMAGES in frame_data: + img = frame_data[OBS_IMAGES] + else: + img_keys = [k for k in frame_data.keys() if "image" in k.lower()] + if img_keys: + img = frame_data[img_keys[0]] + else: + continue + + if isinstance(img, np.ndarray): + img = torch.from_numpy(img) + + if len(img.shape) == 3 and img.shape[-1] in [1, 3, 4]: + img = img.permute(2, 0, 1) + + # Resize to expected input size (256x256 for SigLIP2) + if img.shape[-2:] != (256, 256): + import torch.nn.functional as F + + img = F.interpolate( + img.unsqueeze(0), size=(256, 256), mode="bilinear", align_corners=False + ).squeeze(0) + + # Normalize to [0, 1] if needed + if img.dtype == torch.uint8: + img = img.float() / 255.0 + + frames.append(img) + + if not frames: + continue + + frames_tensor = torch.stack(frames) + + # Predict with correct language + correct_lang = original_languages[i] + correct_ep_rewards = self.predict_episode_rewards(frames_tensor, correct_lang) + + # Predict with incorrect language + incorrect_lang = mismatched_languages[i] + incorrect_ep_rewards = self.predict_episode_rewards(frames_tensor, incorrect_lang) + + correct_rewards.append(correct_ep_rewards) + incorrect_rewards.append(incorrect_ep_rewards) + + except Exception as e: + warnings.warn(f"Failed to process episode {ep_idx} for detection: {e}") + continue + + # Compute detection metrics + detection_results = compute_success_failure_detection(correct_rewards, incorrect_rewards) + + print("Success/Failure Detection Results:") + print(f" Detection accuracy: {detection_results['detection_accuracy']:.4f}") + print(f" Mean correct final reward: {detection_results['mean_correct_final']:.4f}") + print(f" Mean incorrect final reward: {detection_results['mean_incorrect_final']:.4f}") + print(f" Separation score: {detection_results['separation_score']:.4f}") + print(f" Episode pairs evaluated: {detection_results['num_pairs']}") + + return detection_results + + def comprehensive_evaluation( + self, + dataset, + num_episodes: int = 100, + use_interquartile_mean: bool = True, + mismatch_templates: list[str] | None = None, + ) -> dict[str, Any]: + """ + Run comprehensive evaluation including both VOC-S and detection metrics. + + Returns: + Combined evaluation results + """ + print("=" * 60) + print("COMPREHENSIVE RLEARN EVALUATION") + print("=" * 60) + + # VOC-S evaluation + voc_results = self.evaluate_voc_s( + dataset, num_episodes=num_episodes, use_interquartile_mean=use_interquartile_mean + ) + + print("\n" + "=" * 40) + + # Success/failure detection + detection_results = self.evaluate_success_failure_detection( + dataset, num_episodes=num_episodes, mismatch_templates=mismatch_templates + ) + + # Combined results + results = { + "voc_s": voc_results, + "detection": detection_results, + "overall_score": ( + voc_results["voc_s_iqm"] * 0.6 + detection_results["detection_accuracy"] * 0.4 + ), # Weighted combination + } + + print("\n" + "=" * 60) + print(f"OVERALL EVALUATION SCORE: {results['overall_score']:.4f}") + print("=" * 60) + + return results diff --git a/src/lerobot/policies/rlearn/modeling_rlearn.py b/src/lerobot/policies/rlearn/modeling_rlearn.py new file mode 100644 index 000000000..88ca8d58b --- /dev/null +++ b/src/lerobot/policies/rlearn/modeling_rlearn.py @@ -0,0 +1,902 @@ +#!/usr/bin/env python + +# Copyright 2025 The HuggingFace Inc. team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +RLearN: Video-Language Conditioned Reward Model + +Inputs + - images: (B, T, C, H, W) sequence of frames (or single frame with T=1) + - language: list[str] of length B (goal/instruction) + +High-level Architecture + + images (B,T,C,H,W) + | + | per-frame encode + v + +------------------------------+ + | Vision Encoder (frozen) | e.g. SigLIP2 vision tower + +------------------------------+ + | + | pooled per-frame embeddings (BT, H_v) + v + reshape -> (B, T, H_v) -- Linear proj --> (B, T, D) + + Positional Encoding [0..T) + + Optional first-frame bias + | + | language (B, str) + | | + | v + | +------------------------------+ + | | Text Encoder (frozen) | e.g. SigLIP2 text tower + | +------------------------------+ + | | + | | pooled text embedding (B, H_t) + | v + | Linear proj -> (B, D) + | | + +-----------------v----------------------+ + | + +--------------------------v---------------------------+ + | Temporal Causal Transformer (n_layers, n_heads) | + | - self-attention over time with causal mask | + | - cross-attention to a single language token | + +--------------------------+---------------------------+ + | + LayerNorm + Linear Head (D -> 1) + | + v + Output + - reward_logits: (B, T', 1) with T' ≤ T (affected by stride and frame dropout) + +Training + - Loss: composite loss with progress regression, spatial-aware InfoNCE, and ReWiND reversible ranking + +Notes + - Backbones (vision/text) are frozen by default; only projections, temporal module, and head are trainable. + - Stride/frame dropout applied during training can subsample timesteps. +""" + +from __future__ import annotations + +import math + +import torch +import torch.nn.functional as F +from torch import Tensor, nn + +from lerobot.constants import OBS_IMAGE, OBS_IMAGES, OBS_LANGUAGE, REWARD +from lerobot.policies.pretrained import PreTrainedPolicy +from lerobot.policies.rlearn.configuration_rlearn import RLearNConfig + + +class RLearNPolicy(PreTrainedPolicy): + """Video-language conditioned reward model. + + - Visual encoder: frozen SigLIP2 (via transformers AutoModel), returns per-frame embeddings. + - Text encoder: frozen SigLIP2 text tower, returns a language embedding. + - Temporal module: causal transformer over time that cross-attends to language embedding. + - Output: per-timestep reward logits; trainable small head. + """ + + config_class = RLearNConfig + name = "rlearn" + + def __init__(self, config: RLearNConfig): + super().__init__(config) + self.config = config + + # Encoders + from transformers import AutoModel, AutoProcessor + + self.vision_text_model = AutoModel.from_pretrained(config.model_name, trust_remote_code=True) + self.processor = AutoProcessor.from_pretrained(config.model_name, trust_remote_code=True) + + # Detect towers + if hasattr(self.vision_text_model, "vision_model") and hasattr(self.vision_text_model, "text_model"): + self.vision_encoder = self.vision_text_model.vision_model + self.text_encoder = self.vision_text_model.text_model + self.vision_hidden = getattr(self.vision_text_model.config, "vision_config", None).hidden_size + self.text_hidden = getattr(self.vision_text_model.config, "text_config", None).hidden_size + else: + # Fallback if AutoModel exposes pooled outputs directly (rare for SigLIP2) + self.vision_encoder = self.vision_text_model + self.text_encoder = self.vision_text_model + self.vision_hidden = getattr(self.vision_text_model.config, "hidden_size", 768) + self.text_hidden = getattr(self.vision_text_model.config, "hidden_size", 768) + + if config.freeze_backbones: + for p in self.vision_encoder.parameters(): + p.requires_grad = False + for p in self.text_encoder.parameters(): + p.requires_grad = False + + # Linear projections to the shared temporal model dimension + self.visual_proj = nn.Linear(self.vision_hidden, config.dim_model) + self.text_proj = nn.Linear(self.text_hidden, config.dim_model) + + # Positional encodings over time + self.register_buffer( + "positional_encoding", + create_sinusoidal_pos_encoding(config.max_seq_len, config.dim_model), + persistent=False, + ) + # Optional first-frame learned bias to discourage position cheating + self.first_frame_bias = ( + nn.Parameter(torch.zeros(1, 1, config.dim_model)) + if config.use_first_frame_positional_bias + else None + ) + + # Temporal aggregator: causal transformer over time with language cross-attention + self.temporal = TemporalCausalTransformer( + dim_model=config.dim_model, + n_heads=config.n_heads, + n_layers=config.n_layers, + dim_feedforward=config.dim_feedforward, + dropout=config.dropout, + pre_norm=config.pre_norm, + ) + + # Reward head with proper initialization + head_linear = nn.Linear(config.dim_model, 1) + # Initialize with small weights and bias to output values around 0 + nn.init.normal_(head_linear.weight, mean=0.0, std=0.02) + nn.init.constant_(head_linear.bias, 0.0) # Start with 0 bias, sigmoid(0) = 0.5 + + head_layers: list[nn.Module] = [head_linear] + if config.use_tanh_head: + head_layers.append(nn.Tanh()) + self.head = nn.Sequential(*head_layers) + # Projection from scalar value summary to text embedding dim for InfoNCE + self.value_to_text_proj = nn.Linear(1, config.dim_model) + + # Spatial attention for InfoNCE + self.spatial_cross_attn = nn.MultiheadAttention( + embed_dim=config.dim_model, num_heads=config.n_heads, batch_first=True + ) + self.spatial_norm = nn.LayerNorm(config.dim_model) + + # Simple frame dropout probability + self.frame_dropout_p = config.frame_dropout_p + self.stride = max(1, config.stride) + + def get_optim_params(self) -> dict: + # Train only projections, temporal module and head by default if backbones are frozen + return [p for p in self.parameters() if p.requires_grad] + + def reset(self): + pass + + @torch.no_grad() + def predict_action_chunk(self, batch: dict[str, Tensor]) -> Tensor: # Required by base class + raise NotImplementedError("RLearN is a reward model and does not predict actions") + + @torch.no_grad() + def select_action(self, batch: dict[str, Tensor]) -> Tensor: # Required by base class + raise NotImplementedError("RLearN is a reward model and does not select actions") + + @torch.no_grad() + def predict_rewards(self, batch: dict[str, Tensor]) -> Tensor: + """Predict per-timestep rewards for evaluation. + + Args: + batch: Input batch with OBS_IMAGES and optionally OBS_LANGUAGE + + Returns: + Predicted rewards tensor of shape (B, T) + """ + + batch = self.normalize_inputs(batch) + + # Extract frames and form (B, T, C, H, W) + frames = extract_visual_sequence(batch) + B, T, C, H, W = frames.shape + + # Apply stride (no dropout during eval) + idx = torch.arange(0, T, self.stride, device=frames.device) + frames = frames[:, idx] + B, T_eff, C, H, W = frames.shape # NEW: effective length after stride + + # Encode language + lang_emb = encode_language( + batch.get(OBS_LANGUAGE, None), self.text_encoder, self.processor, batch_size=B + ) + lang_emb = self.text_proj(lang_emb) # (B, D) + + # ---- NEW: use the HF processor to standardize size & normalization ---- + # Flatten (B, T_eff, C, H, W) -> (BT, C, H, W) + BT = B * T_eff + flat = frames.reshape(BT, C, H, W).detach().cpu() + + # Convert to uint8 HWC numpy (processor prefers PIL/np) + # If already in [0,1], scale to [0,255] + if flat.dtype != torch.uint8: + if flat.numel() > 0 and float(flat.max()) <= 1.0: + flat = flat * 255.0 + flat = flat.clamp(0, 255).round().to(torch.uint8) + + images = [flat[k].permute(1, 2, 0).numpy() for k in range(flat.size(0))] + + proc_out = self.processor(images=images, return_tensors="pt") + pixel_values = proc_out["pixel_values"].to(next(self.vision_encoder.parameters()).device) + # ---------------------------------------------------------------------- + + # Encode frames through visual tower per frame + vision_outputs = self.vision_encoder(pixel_values=pixel_values) + + # Extract CLS tokens for temporal modeling + if hasattr(vision_outputs, "last_hidden_state"): + cls_tokens = vision_outputs.last_hidden_state[:, 0] # (BT, D_vision) + else: + raise RuntimeError("Vision encoder must output last_hidden_state") + + # Project CLS tokens for temporal sequence + visual_seq = self.visual_proj(cls_tokens).reshape(B, T_eff, self.config.dim_model) # (B, T', D) + + # Add temporal positional encodings and optional first-frame bias + pe = ( + self.positional_encoding[: visual_seq.shape[1]] + .unsqueeze(0) + .to(visual_seq.dtype) + .to(visual_seq.device) + ) + visual_seq = visual_seq + pe + if self.first_frame_bias is not None: + visual_seq = visual_seq.clone() + visual_seq[:, :1] = visual_seq[:, :1] + self.first_frame_bias + + # Temporal model with cross-attention to language + temporal_features = self.temporal(visual_seq, lang_emb, return_features=True) # (B, T', D) + values = self.head(temporal_features).squeeze(-1) # (B, T') + + return values + + def normalize_inputs(self, batch: dict[str, Tensor]) -> dict[str, Tensor]: + # Initial version: no-op; rely on upstream processors if any + return batch + + def normalize_targets(self, batch: dict[str, Tensor]) -> dict[str, Tensor]: + # Initial version: no-op + return batch + + def forward(self, batch: dict[str, Tensor]) -> tuple[Tensor, dict]: + """Compute training loss and logs. + + Expected batch keys: + - OBS_IMAGES: list[Tensor] of shape [(B, C, H, W), ...] per time step or stacked (B, T, C, H, W) + - OBS_LANGUAGE: optional string tokens already tokenized externally or raw strings + - REWARD: (B, T) or (B,) target rewards + """ + batch = self.normalize_inputs(batch) + batch = self.normalize_targets(batch) + + # Extract frames and form (B, T, C, H, W) + frames = extract_visual_sequence(batch) + B, T, C, H, W = frames.shape + + # Apply stride and frame dropout during training + idx = torch.arange(0, T, self.stride, device=frames.device) + if self.training and self.frame_dropout_p > 0.0 and T > 1: + mask = torch.rand_like(idx.float()) > self.frame_dropout_p + idx = idx[mask.long().bool()] + if idx.numel() == 0: + idx = torch.tensor([0], device=frames.device) + frames = frames[:, idx] + + # Encode language + lang_emb = encode_language( + batch.get(OBS_LANGUAGE, None), self.text_encoder, self.processor, batch_size=B + ) + lang_emb = self.text_proj(lang_emb) # (B, D) + + # Encode frames through visual tower per frame + # Flatten time for batched encode + BT = B * frames.shape[1] + flat = frames.reshape(BT, C, H, W) + + # Use HF processor to properly resize and normalize images + # Convert to CPU for processing, then move back to device + flat_cpu = flat.detach().cpu() + + # Convert to uint8 HWC numpy format expected by processor + if flat_cpu.dtype != torch.uint8: + if flat_cpu.numel() > 0 and float(flat_cpu.max()) <= 1.0: + flat_cpu = flat_cpu * 255.0 + flat_cpu = flat_cpu.clamp(0, 255).round().to(torch.uint8) + + # Convert to list of numpy arrays + images = [flat_cpu[k].permute(1, 2, 0).numpy() for k in range(flat_cpu.size(0))] + + # Process with HF processor (resizes to 256x256 and normalizes) + proc_out = self.processor(images=images, return_tensors="pt") + pixel_values = proc_out["pixel_values"].to(next(self.vision_encoder.parameters()).device) + + # Encode through vision model + vision_outputs = self.vision_encoder(pixel_values=pixel_values) + + # Extract BOTH CLS token and spatial patches + if hasattr(vision_outputs, "last_hidden_state"): + all_tokens = vision_outputs.last_hidden_state # (BT, num_tokens, D) + cls_tokens = all_tokens[:, 0] # (BT, D) - CLS token for temporal modeling + spatial_tokens = all_tokens[:, 1:] # (BT, num_patches, D) - spatial patches + else: + raise RuntimeError("Vision encoder must output last_hidden_state with spatial features") + + # Project CLS tokens for temporal sequence + visual_seq = self.visual_proj(cls_tokens).reshape(B, -1, self.config.dim_model) # (B, T', D) + + # Keep spatial features for spatial-aware losses (project them too) + # Assuming 16x16 patches for 256x256 image with patch_size=16 + num_patches = spatial_tokens.shape[1] + spatial_features = self.visual_proj(spatial_tokens).reshape( + B, -1, num_patches, self.config.dim_model + ) # (B, T', num_patches, D) + + # Add temporal positional encodings and optional first-frame bias + pe = ( + self.positional_encoding[: visual_seq.shape[1]] + .unsqueeze(0) + .to(visual_seq.dtype) + .to(visual_seq.device) + ) + visual_seq = visual_seq + pe + if self.first_frame_bias is not None: + visual_seq = visual_seq.clone() + visual_seq[:, :1] = visual_seq[:, :1] + self.first_frame_bias + + # Temporal model with cross-attention to language + temporal_features = self.temporal(visual_seq, lang_emb, return_features=True) # (B, T', D) + values = self.head(temporal_features).squeeze(-1) # (B, T') + + # Targets + target = batch.get(REWARD, None) + loss_dict: dict[str, float] = {} + if target is None: + # If no labels, return zeros loss and logits for inference + loss = values.mean() * 0.0 + loss_dict["has_labels"] = 0.0 + return loss, {**loss_dict, "values_mean": values.mean().item()} + + # Align target with sampled timesteps + if target.dim() == 1: + target = target.unsqueeze(1) # (B, 1) + target = target[:, idx] + + # Composite loss + # 1) Progress regression on z-scored values to match normalized progress labels y in [0,1] + + # Debug: Check if values have enough variance + values_std = values.std() + if values_std < 1e-4: + # Early in training, model outputs are nearly constant + # Use direct MSE loss without z-scoring to encourage variance + import logging + + logging.info(f"Low variance in values (std={values_std:.6f}), using direct MSE") + # Apply sigmoid directly to raw values to get them in [0,1] range + prog_pred = torch.sigmoid(values * 10.0) # Scale up to encourage learning + L_prog = F.mse_loss(prog_pred, torch.clamp(target, 0.0, 1.0)) + else: + # Normal case: use z-score normalization + zV = zscore(values, eps=self.config.zscore_eps) + # Check for NaN after zscore + if torch.isnan(zV).any(): + import logging + + logging.warning(f"NaN after zscore. Values: {values}, zV: {zV}") + # Fallback to direct sigmoid + prog_pred = torch.sigmoid(values * 10.0) + else: + prog_pred = torch.sigmoid(zV) + + L_prog = F.mse_loss(prog_pred, torch.clamp(target, 0.0, 1.0)) + + # Mismatched pairs: randomly shuffle language within batch and require near-zero progress + if self.training and torch.rand(()) < self.config.mismatch_lang_prob and values.size(0) > 1: + shuffled = torch.randperm(B, device=values.device) + lang_mismatch = lang_emb[shuffled] + mismatch_feat = self.temporal(visual_seq, lang_mismatch, return_features=True) + mismatch_V = self.head(mismatch_feat).squeeze(-1) + L_prog_mismatch = F.mse_loss( + torch.sigmoid(zscore(mismatch_V, eps=self.config.zscore_eps)), torch.zeros_like(target) + ) + else: + L_prog_mismatch = torch.zeros((), device=values.device) + + # 2) Spatial-Aware InfoNCE: Use language to attend to relevant spatial regions + # Take late timesteps' spatial features + k = min(self.config.last_k_for_nce, spatial_features.shape[1]) + late_spatial = spatial_features[:, -k:].mean(dim=1) # (B, num_patches, D) + + # Language queries spatial patches via cross-attention + lang_query = lang_emb.unsqueeze(1) # (B, 1, D) + attended_spatial, spatial_attn_weights = self.spatial_cross_attn( + query=lang_query, key=late_spatial, value=late_spatial, need_weights=True + ) + attended_spatial = self.spatial_norm(attended_spatial).squeeze(1) # (B, D) + + # Contrastive loss with spatially-attended features + attended_spatial = F.normalize(attended_spatial, dim=-1) + lang_norm = F.normalize(lang_emb, dim=-1) + logits_spatial = (attended_spatial @ lang_norm.t()) / self.config.nce_temperature # (B, B) + targets_nce = torch.arange(B, device=values.device) + L_spatial_nce = F.cross_entropy(logits_spatial, targets_nce) + + # 3) ReWiND Reversible Ranking: Learn from both forward and reversed trajectories + # This teaches the model what constitutes progress vs undoing progress + L_rank_forward, L_rank_reverse = reversible_ranking_loss( + values, + target, + margin=self.config.ranking_margin, + num_pairs=self.config.num_ranking_pairs, + min_gap=self.config.min_rank_gap, + ) + L_rewind = L_rank_forward + L_rank_reverse + + # Check for NaNs in individual loss components + if torch.isnan(L_prog): + import logging + + logging.warning(f"NaN in L_prog. Values: {values}, Target: {target}") + # Return a small loss with gradients instead of zero + L_prog = values.mean() * 0.0 + 0.01 + + if torch.isnan(L_spatial_nce): + import logging + + logging.warning("NaN in L_spatial_nce") + # Use a dummy loss that maintains gradients + L_spatial_nce = attended_spatial.mean() * 0.0 + 0.01 + + if torch.isnan(L_rewind): + import logging + + logging.warning("NaN in L_rewind") + # Use values to maintain gradient flow + L_rewind = values.mean() * 0.0 + 0.01 + + loss = ( + self.config.lambda_prog * (L_prog + L_prog_mismatch) + + self.config.lambda_spatial_nce * L_spatial_nce + + self.config.lambda_rewind * L_rewind + ) + + # Final NaN check + if torch.isnan(loss): + import logging + + logging.warning("NaN loss detected, using fallback loss") + # Use a small loss that maintains gradients + loss = values.mean() * 0.0 + 0.01 + + loss_dict.update( + { + "loss_prog": L_prog.item() if not torch.isnan(L_prog) else 0.0, + "loss_prog_mismatch": L_prog_mismatch.item() if not torch.isnan(L_prog_mismatch) else 0.0, + "loss_spatial_nce": L_spatial_nce.item() if not torch.isnan(L_spatial_nce) else 0.0, + "loss_rewind_forward": L_rank_forward.item() if not torch.isnan(L_rank_forward) else 0.0, + "loss_rewind_reverse": L_rank_reverse.item() if not torch.isnan(L_rank_reverse) else 0.0, + } + ) + + loss_dict["loss"] = loss.item() + loss_dict["values_mean"] = values.mean().item() + return loss, loss_dict + + +class TemporalCausalTransformer(nn.Module): + def __init__( + self, + dim_model: int, + n_heads: int, + n_layers: int, + dim_feedforward: int, + dropout: float, + pre_norm: bool, + ): + super().__init__() + self.layers = nn.ModuleList( + [ + TemporalCausalTransformerLayer(dim_model, n_heads, dim_feedforward, dropout, pre_norm) + for _ in range(n_layers) + ] + ) + self.norm = nn.LayerNorm(dim_model) + self.head = nn.Linear(dim_model, 1) + + def forward(self, x: Tensor, lang_emb: Tensor, return_features: bool = False) -> Tensor: + # x: (B, T, D), lang_emb: (B, D) + B, T, D = x.shape + # Prepare language as a single token for cross-attention context + lang_token = lang_emb.unsqueeze(1) # (B, 1, D) + + x = x.transpose(0, 1) # (T, B, D) + lang_token = lang_token.transpose(0, 1) # (1, B, D) + causal_mask = generate_causal_mask(T, device=x.device) + for layer in self.layers: + x = layer(x, lang_token, causal_mask) + x = self.norm(x) + x = x.transpose(0, 1) # (B, T, D) + if return_features: + return x + return self.head(x) # (B, T, 1) + + +class TemporalCausalTransformerLayer(nn.Module): + def __init__(self, dim_model: int, n_heads: int, dim_feedforward: int, dropout: float, pre_norm: bool): + super().__init__() + self.self_attn = nn.MultiheadAttention(dim_model, n_heads, dropout=dropout, batch_first=False) + self.cross_attn = nn.MultiheadAttention(dim_model, n_heads, dropout=dropout, batch_first=False) + self.linear1 = nn.Linear(dim_model, dim_feedforward) + self.linear2 = nn.Linear(dim_feedforward, dim_model) + self.dropout = nn.Dropout(dropout) + self.dropout1 = nn.Dropout(dropout) + self.dropout2 = nn.Dropout(dropout) + self.dropout3 = nn.Dropout(dropout) + self.norm1 = nn.LayerNorm(dim_model) + self.norm2 = nn.LayerNorm(dim_model) + self.norm3 = nn.LayerNorm(dim_model) + self.activation = F.gelu + self.pre_norm = pre_norm + + def forward(self, x: Tensor, lang_token: Tensor, causal_mask: Tensor) -> Tensor: + # Self-attention with causal mask + residual = x + if self.pre_norm: + x = self.norm1(x) + x = self.self_attn(x, x, x, attn_mask=causal_mask)[0] + x = residual + self.dropout1(x) + if not self.pre_norm: + x = self.norm1(x) + + # Cross-attention to language token (keys/values from language, queries are time tokens) + residual = x + if self.pre_norm: + x = self.norm2(x) + # Broadcast language token across time + T = x.shape[0] + lang_kv = lang_token.expand(1, x.shape[1], x.shape[2]) # (1, B, D) + x = self.cross_attn(x, lang_kv, lang_kv)[0] + x = residual + self.dropout2(x) + if not self.pre_norm: + x = self.norm2(x) + + # Feed-forward + residual = x + if self.pre_norm: + x = self.norm3(x) + x = self.linear2(self.dropout(self.activation(self.linear1(x)))) + x = residual + self.dropout3(x) + if not self.pre_norm: + x = self.norm3(x) + return x + + +def create_sinusoidal_pos_encoding(max_len: int, dim: int) -> Tensor: + position = torch.arange(0, max_len, dtype=torch.float32).unsqueeze(1) # (L, 1) + div_term = torch.exp(torch.arange(0, dim, 2).float() * (-math.log(10000.0) / dim)) # (D/2) + pe = torch.zeros(max_len, dim) + pe[:, 0::2] = torch.sin(position * div_term) + pe[:, 1::2] = torch.cos(position * div_term) + return pe # (L, D) + + +def generate_causal_mask(T: int, device=None) -> Tensor: + # (T, T) with True where masking should occur for MultiheadAttention expects float mask or bool? + mask = torch.full((T, T), float("-inf"), device=device) + mask = torch.triu(mask, diagonal=1) + return mask + + +def extract_visual_sequence(batch: dict[str, Tensor]) -> Tensor: + # Accept various image key formats from datasets + # Try multiple common key patterns + + # List of possible image keys to check, in order of preference + possible_keys = [ + OBS_IMAGES, # 'observation.images' + OBS_IMAGE, # 'observation.image' + "observation.images.image", # nested format from some datasets + ] + + for key in possible_keys: + if key in batch: + image_val = batch[key] + + if isinstance(image_val, list) and len(image_val) > 0: + # List of (B, C, H, W) -> stack over time + return torch.stack(image_val, dim=1) + elif torch.is_tensor(image_val): + # Tensor of shape (B, T, C, H, W) or (B, C, H, W) + if image_val.dim() == 5: + # Already has time dimension + return image_val + elif image_val.dim() == 4: + # Add time dimension (single frame) + return image_val.unsqueeze(1) + else: + raise ValueError( + f"'{key}' must be a Tensor of shape (B,T,C,H,W) or (B,C,H,W), got shape {image_val.shape}" + ) + + # If no image key found, provide helpful error with available keys + available_keys = list(batch.keys()) + image_like_keys = [k for k in available_keys if "image" in k.lower()] + raise ValueError( + f"Could not find image data in batch. Looked for keys: {possible_keys}. " + f"Available keys with 'image': {image_like_keys}. " + f"All keys: {available_keys}" + ) + + +def encode_language( + language_input: Tensor | list | str | None, text_encoder, processor, batch_size: int +) -> Tensor: + # language_input can be: list[str] length B, or None + if language_input is None: + texts = [""] * batch_size + elif isinstance(language_input, list): + texts = language_input + else: + # Single string for the batch + texts = [str(language_input)] * batch_size + + inputs = processor(text=texts, padding=True, return_tensors="pt") + inputs = {k: v.to(next(text_encoder.parameters()).device) for k, v in inputs.items()} + outputs = text_encoder(**inputs) + if hasattr(outputs, "pooler_output"): + emb = outputs.pooler_output + elif hasattr(outputs, "last_hidden_state"): + emb = outputs.last_hidden_state[:, 0] + else: + raise RuntimeError("Unsupported text encoder output structure") + return emb + + +def pairwise_ranking_loss(logits: Tensor, target: Tensor, margin: float = 0.1, num_pairs: int = 32) -> Tensor: + # logits, target: (B, T) + B, T = logits.shape + if T < 2: + return logits.mean() * 0.0 + # Sample pairs i r_i when target_j > target_i + losses = [] + for _ in range(num_pairs): + i = torch.randint(0, T - 1, (B,), device=logits.device) + j = i + torch.randint(1, T - i.max(), (1,), device=logits.device) + j = j.expand_as(i) + li = logits[torch.arange(B), i] + lj = logits[torch.arange(B), j] + yi = target[torch.arange(B), i] + yj = target[torch.arange(B), j] + sign = torch.sign(yj - yi) + # hinge: max(0, margin - sign*(lj-li)) + loss = F.relu(margin - sign * (lj - li)) + losses.append(loss.mean()) + return torch.stack(losses).mean() + + +def zscore(x: Tensor, eps: float = 1e-3) -> Tensor: + """Z-score normalization with numerical stability.""" + # Handle both (B,) and (B, T) shapes + if x.dim() == 1: + x = x.unsqueeze(1) # Make it (B, 1) + + B, T = x.shape + + # If only one timestep, can't compute meaningful std across time + if T == 1: + # Just use tanh to bound values instead of z-score + return torch.tanh(x * 0.1) # Scale and bound + + # Compute mean and std across time dimension + mean = x.mean(dim=1, keepdim=True) + std = x.std(dim=1, keepdim=True, unbiased=False) + + # Check if std is valid (not zero or NaN) + std_is_valid = (std > eps) & (~torch.isnan(std)) + + # Safe std for division + std_safe = torch.where(std_is_valid, std, torch.ones_like(std)) + + # Compute z-score where valid + z = (x - mean) / std_safe + + # For invalid cases, use tanh of centered values + z_fallback = torch.tanh((x - mean) * 0.1) + z = torch.where(std_is_valid.expand_as(z), z, z_fallback) + + # Final safety clamp + z = torch.clamp(z, min=-5.0, max=5.0) + + # Check for any remaining NaNs and replace with 0 + z = torch.nan_to_num(z, nan=0.0) + + return z + + +def temporal_logistic_ranking( + values: Tensor, margin: float = 0.1, min_gap: int = 1, num_pairs: int = 64 +) -> Tensor: + """VLC-style temporal monotonicity: encourage V[j] > V[i] for j>i. + + Samples pairs (i tuple[Tensor, Tensor]: + """ReWiND-style reversible ranking: learn from both forward and reversed trajectories. + + Key insight: If a trajectory shows progress forward, its reverse shows undoing progress. + By training on both, the model learns what constitutes progress vs regression. + + Args: + values: (B, T) predicted values + target: (B, T) progress labels (0 to 1 for forward progress) + margin: Margin for ranking loss + num_pairs: Number of (far, near) pairs to sample + min_gap: Minimum temporal gap between pairs + + Returns: + forward_loss: Loss from forward trajectory pairs + reverse_loss: Loss from reversed trajectory pairs + """ + B, T = values.shape + if T < 2: + zero_loss = values.mean() * 0.0 + return zero_loss, zero_loss + + device = values.device + + # Forward trajectory ranking: later frames should have higher values + forward_losses = [] + for _ in range(num_pairs // 2): + # Sample far-near pairs (far is earlier, near is later) + far_idx = torch.randint(0, max(1, T - min_gap), (B,), device=device) + near_idx = far_idx + torch.randint(min_gap, T - far_idx.max(), (1,), device=device) + near_idx = near_idx.expand_as(far_idx) + + v_far = values[torch.arange(B), far_idx] + v_near = values[torch.arange(B), near_idx] + + # Near (later) should have higher value than far (earlier) + forward_losses.append(F.softplus(margin - (v_near - v_far)).mean()) + + # Reversed trajectory ranking: treat reversed sequence with inverted progress + # Reverse both values and targets + reversed_values = values.flip(dims=[1]) # Reverse time dimension + reversed_target = 1.0 - target.flip(dims=[1]) # Invert and reverse progress + + reverse_losses = [] + for _ in range(num_pairs // 2): + # In reversed trajectory, what was "later" is now "earlier" + far_idx = torch.randint(0, max(1, T - min_gap), (B,), device=device) + near_idx = far_idx + torch.randint(min_gap, T - far_idx.max(), (1,), device=device) + near_idx = near_idx.expand_as(far_idx) + + v_far_rev = reversed_values[torch.arange(B), far_idx] + v_near_rev = reversed_values[torch.arange(B), near_idx] + + # In reversed trajectory with inverted progress, + # near (which was originally earlier) should still have higher value + reverse_losses.append(F.softplus(margin - (v_near_rev - v_far_rev)).mean()) + + forward_loss = torch.stack(forward_losses).mean() if forward_losses else values.mean() * 0.0 + reverse_loss = torch.stack(reverse_losses).mean() if reverse_losses else values.mean() * 0.0 + + return forward_loss, reverse_loss + + +def intra_trajectory_directional_ranking( + values: Tensor, progress: Tensor, margin: float = 0.2, num_pairs: int = 64, min_gap: int = 1 +) -> Tensor: + """Directional ranking within trajectory based on progress labels. + + For pairs i y_i), enforce V_j > V_i + - If progress decreases (y_j < y_i), enforce V_j < V_i + - Ignore pairs where progress is unchanged + + Uses logistic loss: log(1 + exp(m - s_ij * (V_j - V_i))) + where s_ij = sign(y_j - y_i) + """ + B, T = values.shape + if T < 2: + return values.mean() * 0.0 + + losses = [] + device = values.device + + for _ in range(num_pairs): + # Sample time pairs i < j + i = torch.randint(0, max(1, T - min_gap), (B,), device=device) + max_j = min(T, i.max() + T - min_gap) + j = i + torch.randint(min_gap, max_j - i.min(), (1,), device=device) + j = j.expand_as(i).clamp(max=T - 1) + + # Get values and progress at sampled times + vi = values[torch.arange(B), i] + vj = values[torch.arange(B), j] + yi = progress[torch.arange(B), i] + yj = progress[torch.arange(B), j] + + # Compute direction sign + s_ij = torch.sign(yj - yi) + + # Only compute loss for non-zero progress differences + mask = s_ij != 0 + if mask.any(): + diff = vj - vi + loss = torch.log1p(torch.exp(margin - s_ij * diff)) + losses.append(loss[mask].mean()) + + return torch.stack(losses).mean() if losses else values.mean() * 0.0 + + +def inter_instruction_contrastive_ranking( + values_correct: Tensor, values_incorrect: Tensor, margin: float = 0.2 +) -> Tensor: + """Ranking between correct and incorrect instructions for same frames. + + Enforces V_t(z) > V_t(z') where z is correct instruction and z' is incorrect. + Uses logistic loss: log(1 + exp(m - (V_t(z) - V_t(z')))) + """ + diff = values_correct - values_incorrect + return torch.log1p(torch.exp(margin - diff)).mean() + + +def flatness_under_mismatch(values: Tensor, epsilon: float = 0.05, num_pairs: int = 32) -> Tensor: + """Enforce flat values over time for mismatched instructions. + + For trajectory with wrong instruction, V should not change much over time. + Uses Huber loss to allow small variations within epsilon band. + """ + B, T = values.shape + if T < 2: + return values.mean() * 0.0 + + losses = [] + device = values.device + + for _ in range(num_pairs): + i = torch.randint(0, T - 1, (B,), device=device) + j = torch.randint(i.min() + 1, T, (1,), device=device) + j = j.expand_as(i) + + vi = values[torch.arange(B), i] + vj = values[torch.arange(B), j] + + # Huber loss with small delta for near-zero target + diff = vj - vi + loss = F.huber_loss(diff, torch.zeros_like(diff), delta=epsilon) + losses.append(loss) + + return torch.stack(losses).mean() diff --git a/src/lerobot/policies/rlearn/processor_rlearn.py b/src/lerobot/policies/rlearn/processor_rlearn.py new file mode 100644 index 000000000..85dc0c6d0 --- /dev/null +++ b/src/lerobot/policies/rlearn/processor_rlearn.py @@ -0,0 +1,126 @@ +#!/usr/bin/env python + +# Copyright 2025 The HuggingFace Inc. team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from dataclasses import dataclass +from typing import Any + +from lerobot.configs.types import PolicyFeature +from lerobot.constants import OBS_LANGUAGE +from lerobot.policies.rlearn.configuration_rlearn import RLearNConfig +from lerobot.processor import ( + DeviceProcessor, + NormalizerProcessor, + RenameProcessor, + RobotProcessor, + ToBatchProcessor, + TokenizerProcessor, + UnnormalizerProcessor, +) +from lerobot.processor.pipeline import ( + ComplementaryDataProcessor, + EnvTransition, + ProcessorStepRegistry, + TransitionKey, +) + + +def make_rlearn_processor( + config: RLearNConfig, dataset_stats: dict[str, dict[str, Any]] | None = None +) -> tuple[RobotProcessor, RobotProcessor]: + """Build pre/post processors for RLearN. + + Responsibilities moved out of the model: + - Normalize inputs (images) using dataset stats + - Ensure batching + - Map complementary_data.task to observation.language when available + - Tokenize language into observation.language.tokens / attention_mask + - Move to/from device + """ + + input_steps = [ + # No renaming by default, but keep for future extensibility + RenameProcessor(rename_map={}), + NormalizerProcessor( + features={**config.input_features, **config.output_features}, + norm_map=config.normalization_mapping, + stats=dataset_stats, + ), + ToBatchProcessor(), + RLearnLanguageFromTaskProcessor(), + # Use the same model name for tokenizer to keep vocab aligned with text tower + TokenizerProcessor( + tokenizer_name=config.model_name, + max_length=128, + padding="max_length", + truncation=True, + padding_side="right", + ), + DeviceProcessor(device=config.device), + ] + + output_steps = [ + DeviceProcessor(device="cpu"), + UnnormalizerProcessor( + features=config.output_features, norm_map=config.normalization_mapping, stats=dataset_stats + ), + ] + + return RobotProcessor(steps=input_steps, name="robot_preprocessor"), RobotProcessor( + steps=output_steps, name="robot_postprocessor" + ) + + +@dataclass +@ProcessorStepRegistry.register(name="rlearn_language_from_task") +class RLearnLanguageFromTaskProcessor(ComplementaryDataProcessor): + """Copy complementary_data['task'] into observation['observation.language'] if present. + + This ensures the model can consume a raw language string when tokenization is not used, + while TokenizerProcessor can still create tokenized fields. + """ + + task_key: str = "task" + + def __call__(self, transition: EnvTransition) -> EnvTransition: # type: ignore[override] + complementary_data = transition.get(TransitionKey.COMPLEMENTARY_DATA) + if not complementary_data or self.task_key not in complementary_data: + return transition + + task = complementary_data.get(self.task_key) + if task is None: + return transition + + # Normalize to list[str] + if isinstance(task, str): + task_list = [task] + elif isinstance(task, list) and all(isinstance(t, str) for t in task): + task_list = task + else: + return transition + + observation = transition.get(TransitionKey.OBSERVATION) or {} + # Do not overwrite if user already provided observation.language + if OBS_LANGUAGE not in observation: + observation[OBS_LANGUAGE] = task_list + transition[TransitionKey.OBSERVATION] = observation + return transition + + def transform_features(self, features: dict[str, PolicyFeature]) -> dict[str, PolicyFeature]: # noqa: D401 + # Adds nothing to features; only mirrors complementary_data.task into observation + return features + + def get_config(self) -> dict[str, Any]: + return {"task_key": self.task_key} diff --git a/src/lerobot/policies/rlearn/rlearn_plan.md b/src/lerobot/policies/rlearn/rlearn_plan.md new file mode 100644 index 000000000..6e7d720cf --- /dev/null +++ b/src/lerobot/policies/rlearn/rlearn_plan.md @@ -0,0 +1,136 @@ +## General Value/Reward Learning: + +I want to implement a general/universal vision and language value function or reward model for robotics/video tasks. Also called a video language conditioned reward model. Integrated with already existing LeRobot code if convenient, use the LeRobot Dataset for dataset and store the reward for a frame in the lerobot frame itself. + +Inspired by these papers: + +- ReWiND; https://arxiv.org/pdf/2505.10911 (Most applicable and main paper I want to implement ideas from) and code: https://github.com/lucidrains/rewind-reward-pytorch +- LIV; https://arxiv.org/pdf/2306.00958 (Most applicable and 2nd main paper I want to implement ideas from) and code https://github.com/penn-pal-lab/LI +- VLC: Video-Language Critic: Transferable Reward Functions for Language-Conditioned Robotics: https://arxiv.org/pdf/2405.19988 (Most applicable and 3rd paper I want to implement ideas from) and code: https://github.com/minttusofia/video_language_critic + +And these papers which are also relevant: + +- https://www.dyna.co/dyna-1/research (Main company I want to reproduce the eventual results from) +- vip; https://arxiv.org/pdf/2210.00030 +- uvd; https://arxiv.org/pdf/2310.08581 +- vlm in context; https://arxiv.org/pdf/2411.04549 +- https://www.youtube.com/watch?v=JfZYtpEisoM + +Little less relevant but still similar papers: + +- Learning Generalizable Robotic Reward Functions from “In-The-Wild” Human Videos, +- XIRL: Cross-embodiment Inverse Reinforcement Learning, +- Video-Language Critic: Transferable Reward https://arxiv.org/pdf/2405.19988 +- Functions for Language-Conditioned Robotics, +- LORel, Language-Driven Representation Learning for Robotics https://sites.google.com/view/robotlorel +- RoboCLIP: One Demonstration is Enough to Learn Robot Policies https://arxiv.org/pdf/2310.07899 +- Points2Rewards: learn first key points and then uses the keypoints to learn general value function/policy https://semrob.github.io/docs/2025_rss_semrob.github.io_paper20.pdf +- Language-Driven Representation Learning for Robotics: https://arxiv.org/pdf/2302.12766v1 +- R3M: A Universal Visual Representation for Robot Manipulation: https://arxiv.org/pdf/2203.12601v3 + +Input should be the current image or whole video and the task goal specified in text/language. Output is current reward. +Archiutecture: +_ inputs: video o1:T (or current o1:t), language z; +_ google/siglip2-large-patch16-256: https://huggingface.co/google/siglip2-large-patch16-256 \* Temporal module: small causal transformer (“cross-modal sequential aggregator”), with first-frame positional embedding (to avoid position cheating), frame-dropout, and stride sampling; outputs per-timestep logits. + +Loss: See this chatgpt thread: https://chatgpt.com/s/t_68999a50a0b081919abc365cdd205e01 + +Past images: (for example a reward methoid go to 3rd floor, has to know what floor it was on and what pas actions it did, can we attend or encorperate images of decision from history in one way?) Maybe via this paper: Learning Long-Context Diffusion Policies via Past-Token Prediction + +Amount of frames needed for test/generalization: 1M frames? or ~20% of IPEC-COMMUNITY/bc_z_lerobot + +Eval: +Implement something like voc score , or ROC rank order correlation between reward leanredna and ev reward from sim, or use something else to do additional evaluation + +Ideas: + +- Incorporate training on multiple horizons: as in label same dataset for longer horizons: make a sandwich (long), put cheese on bread (medium) and even smaller horizons: go down or close gripper (small) +- Incorporate navigation goals “walk towards the kitchen”, make sure we fix CLIP contrastive learning issue of positional text misunderstanding where model doesnnt learn difference between "horse right of cow" and "horse left of cow" “Move right” potentially train with more other data or even actionable world models such as Genie 3 (https://deepmind.google/discover/blog/genie-3-a-new-frontier-for-world-models/) + +How to use a general reward model (use cases): - Train rl policy on it - Success detection - Do exploraion - Do task via planning and search to optimize reward - Filter out bad episodes in large datasets from imitation learning + +Potential Datasets: (start with dataset that is most clean for this and works best with chosen way of doing evals) +_ Epic-Kitchens-100 +_ Something-Something v. 2 Dataset https://www.qualcomm.com/developer/software/something-something-v-2-dataset +_ Ego4D (3000 hours) +_ Open X-Embodiment (OXE) +_ Age bot world: https://huggingface.co/datasets/agibot-world/AgiBotWorld-Alpha +_ GTEA+ Gaze: https://cbs.ic.gatech.edu/fpv/ +_ YouCook2 dataset +_ HOWTO100M: https://www.di.ens.fr/willow/research/howto100m/ + +Also in plan include investigating/incorperating these two things: + +- Curriculum: Start training on easier distinctions (e.g. very early vs very late frames which are easy to tell apart) then gradually ask the model to distinguish more subtle differences (frames that are closer in time). This curriculum can be implemented by initially using pairs far apart in the trajectory for ranking, then moving to closer pairs as accuracy improves. +- Augmentations: As mentioned, heavy image augmentation (random crops, slight noise) is often used so that the reward model focuses on high-level task progress features rather than pixel-level cues. For video models, temporal augmentation like random frame skipping can also make the model robust to different speeds. + +### Implemented Loss (Spatial-Aware Composite Loss) + +Our implementation uses a **composite loss with spatial awareness** to address the limitations of standard contrastive learning (e.g., CLIP's inability to distinguish "move left" vs "move right"). The loss has three components: + +##### 1) Progress Regression Loss (L_prog) + +Predicts normalized progress values for each timestep: + +$$ +L_{\text{prog}} = \text{MSE}(\sigma(z(V_t)), y_t) +$$ + +where $z(·)$ is z-score normalization, $\sigma$ is sigmoid, and $y_t \in [0,1]$ is the progress label. +**Purpose:** Grounds the model in actual task progress, not just visual-language similarity. + +##### 2) Spatial-Aware InfoNCE Loss (L_spatial_nce) + +Instead of using pooled features, we: + +- Extract spatial patch features from SigLIP2's last_hidden_state (e.g., 16×16 patches) +- Use cross-attention where language queries attend to relevant spatial regions +- Compute contrastive loss on the attended spatial features + +$$ +L_{\text{spatial-nce}} = -\log \frac{\exp(s_{ii}/\tau)}{\sum_j \exp(s_{ij}/\tau)} +$$ + +where $s_{ij}$ is the similarity between spatially-attended features from trajectory $i$ and language $j$. +**Purpose:** Preserves spatial information that pooling discards, enabling distinction of spatial relationships. + +##### 3) ReWiND Reversible Ranking Loss (L_rewind) + +Based on ReWiND's key insight: learn from both forward AND reversed trajectories. +The loss has two components: + +- **Forward ranking**: Sample (far, near) pairs where near is later in time, enforce $V_{\text{near}} > V_{\text{far}}$ +- **Reverse ranking**: Reverse the trajectory and invert progress labels, then apply same ranking + +$$ +L_{\text{rewind}} = L_{\text{forward}} + L_{\text{reverse}} +$$ + +where both use: $\text{softplus}(m - (V_{\text{near}} - V_{\text{far}}))$ + +**Purpose:** By training on reversed trajectories with inverted progress, the model learns to distinguish progress from undoing progress. This is ReWiND's core contribution - understanding that tasks can be reversible. + +##### Total Loss: + +$$ +L = \lambda_{\text{prog}} L_{\text{prog}} + \lambda_{\text{spatial-nce}} L_{\text{spatial-nce}} + \lambda_{\text{rewind}} L_{\text{rewind}} +$$ + +Default weights: $\lambda_{\text{prog}}=1.0$, $\lambda_{\text{spatial-nce}}=0.5$, $\lambda_{\text{rewind}}=0.4$ + +### TODOs: + +- Implement first architecture [x] +- Implement processors [x] +- Choose right loss metric(s) [x] +- Make dataset with script that generated the dataset (IPEC-COMMUNITY/bc_z_lerobot) ready in lerobot format (and be able to visualize in dataset visualizer) + - Annotate with ReWiND-style 0→1 progress rewards [x] + - Visualize to check [x] +- Implement eval score or metric that is robust and can deal with generalization/is a good metric to try different architectures. And use it in an eval jupyter notebook with visalization of the live reward next to the video for part of the dataset: VOC score and score with correct and incorrect language captions [x] +- Do first training [] +- Try different losses [] +- Switch to DINO v3 as encoder Base 86 M: https://huggingface.co/facebook/dinov3-vitb16-pretrain-lvd1689m with HuggingFaceTB/SmolLM2-135M-Instruct ? +- Add more artificial text to dataset generated by vlm (google gemini) [] + - See google gemini vlm caption from Leandro [] + - Multiple captions per video, creat method to generate as much data as possible etc [] https://arxiv.org/abs/2508.13446 +- Add droid [] diff --git a/src/lerobot/processor/tokenizer_processor.py b/src/lerobot/processor/tokenizer_processor.py index 796acf924..3130de109 100644 --- a/src/lerobot/processor/tokenizer_processor.py +++ b/src/lerobot/processor/tokenizer_processor.py @@ -145,10 +145,13 @@ class TokenizerProcessor: observation = dict(observation) # Make a copy # Add tokenized data to observation - observation[f"{OBS_LANGUAGE}.tokens"] = tokenized_prompt["input_ids"] - observation[f"{OBS_LANGUAGE}.attention_mask"] = tokenized_prompt["attention_mask"].to( - dtype=torch.bool - ) + input_ids = tokenized_prompt["input_ids"] + attention_mask = tokenized_prompt.get("attention_mask") + if attention_mask is None: + # Some tokenizers (e.g., SigLIP text) may not return attention_mask; default to ones + attention_mask = torch.ones_like(input_ids) + observation[f"{OBS_LANGUAGE}.tokens"] = input_ids + observation[f"{OBS_LANGUAGE}.attention_mask"] = attention_mask.to(dtype=torch.bool) transition[TransitionKey.OBSERVATION.value] = observation # type: ignore[misc] return transition diff --git a/src/lerobot/scripts/annotate_dataset_rewards.py b/src/lerobot/scripts/annotate_dataset_rewards.py new file mode 100644 index 000000000..86c2db5a7 --- /dev/null +++ b/src/lerobot/scripts/annotate_dataset_rewards.py @@ -0,0 +1,335 @@ +#!/usr/bin/env python + +# Copyright 2025 The HuggingFace Inc. team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +Add ReWiND-style linear progress rewards to existing LeRobot datasets. + +This script creates a complete copy of the dataset with rewards added to each frame. +It downloads the original dataset (including videos), adds rewards, and pushes everything to a new repository. + +Usage: + # Create full dataset copy with rewards + python src/lerobot/scripts/annotate_dataset_rewards.py --input-repo IPEC-COMMUNITY/bc_z_lerobot --output-repo username/bc_z_with_rewards + + # Test with 1% of episodes + python src/lerobot/scripts/annotate_dataset_rewards.py --input-repo IPEC-COMMUNITY/bc_z_lerobot --output-repo username/test_rewards --percentage 1 +""" + +import argparse +import shutil +from pathlib import Path +from tempfile import mkdtemp + +import numpy as np +import torch +from PIL import Image +from tqdm import tqdm + +from lerobot.constants import REWARD +from lerobot.datasets.lerobot_dataset import LeRobotDataset, LeRobotDatasetMetadata + + +def compute_linear_progress_reward(episode_length: int) -> np.ndarray: + """ + Compute linear progress rewards from 0 to 1. + + ReWiND-style: progress increases linearly from 0 at start to 1 at completion. + + Args: + episode_length: Number of frames in the episode + + Returns: + rewards: Array of shape (episode_length,) with values linearly from 0 to 1 + """ + return np.linspace(0, 1, episode_length, dtype=np.float32) + + +def main(): + parser = argparse.ArgumentParser( + description="Add linear progress rewards to LeRobot dataset and push to Hub" + ) + parser.add_argument( + "--input-repo", + type=str, + default="IPEC-COMMUNITY/bc_z_lerobot", + help="Input dataset repository on HuggingFace Hub", + ) + parser.add_argument( + "--output-repo", + type=str, + required=True, + help="Output dataset repository name (e.g., username/dataset_with_rewards)", + ) + parser.add_argument( + "--percentage", + type=float, + default=100.0, + help="Percentage of episodes to process (useful for testing, e.g., 1 for 1%%)", + ) + parser.add_argument( + "--private", + action="store_true", + help="Make the output repository private", + ) + parser.add_argument( + "--local-dir", + type=str, + default=None, + help="Local directory to save the modified dataset (defaults to ~/.cache/huggingface/lerobot/)", + ) + + args = parser.parse_args() + + print("=" * 60) + print("FULL DATASET COPY WITH REWARDS") + print("This will download the entire dataset including videos,") + print("add rewards, and push everything to a new repository.") + print("=" * 60) + + # First, load just the metadata to get total episodes + print(f"\nLoading metadata from Hub: {args.input_repo}") + + # Load metadata only first + metadata = LeRobotDatasetMetadata(repo_id=args.input_repo) + total_episodes = metadata.total_episodes + + # Calculate which episodes to process + num_episodes_to_process = max(1, int(total_episodes * args.percentage / 100)) + episodes_to_load = list(range(num_episodes_to_process)) # Load only first N episodes + + print(f"Dataset has {total_episodes} episodes") + print(f"Processing {num_episodes_to_process} episodes ({args.percentage}%)") + + # Determine local directory for the new dataset + if args.local_dir: + local_dir = Path(args.local_dir) + else: + from lerobot.constants import HF_LEROBOT_HOME + + local_dir = HF_LEROBOT_HOME / args.output_repo + + # Use a temporary directory for downloading source dataset + temp_source_dir = Path(mkdtemp(prefix="lerobot_source_")) + + # Load the dataset with videos to temp directory + print("Downloading dataset with videos to temp directory...") + print(f"Temp directory: {temp_source_dir}") + dataset = LeRobotDataset( + repo_id=args.input_repo, + root=temp_source_dir, # Temporary location for source + episodes=episodes_to_load if args.percentage < 100 else None, + download_videos=True, # Download videos + ) + + print(f"Downloaded {dataset.num_episodes} episodes with {dataset.num_frames} frames") + + # Create a new dataset with rewards + print(f"\nCreating new dataset at: {local_dir}") + + # Clean up any existing directory from previous runs + if local_dir.exists(): + print(f"⚠️ Directory already exists: {local_dir}") + print(" Removing it to start fresh...") + shutil.rmtree(local_dir) + + # Define features including reward + # Simply copy all features from the original dataset + new_features = dict(dataset.features) + + # Add reward feature + new_features[REWARD] = {"shape": (1,), "dtype": "float32", "names": ["reward"]} + + # Determine which features are videos + video_keys = dataset.meta.video_keys if hasattr(dataset.meta, "video_keys") else [] + image_keys = dataset.meta.image_keys if hasattr(dataset.meta, "image_keys") else [] + visual_keys = set(video_keys + image_keys) + + print(f" Visual features to be handled as videos: {visual_keys}") + + # Check for language features + language_keys = [ + k + for k in dataset.features.keys() + if any(lang in k.lower() for lang in ["language", "task", "instruction", "text"]) + ] + if language_keys: + print(f" Language/task features found: {language_keys}") + + # Copy dataset structure to new location + new_dataset = LeRobotDataset.create( + repo_id=args.output_repo, + root=local_dir, + fps=dataset.fps, + features=new_features, + robot_type=dataset.meta.robot_type, + use_videos=len(dataset.meta.video_keys) > 0, + ) + + # Process each episode + print("\nAdding rewards to episodes...") + + episode_data_index = dataset.episode_data_index + + for ep_idx, episode_idx in enumerate(tqdm(episodes_to_load)): + # Get episode boundaries + ep_start = episode_data_index["from"][ep_idx].item() + ep_end = episode_data_index["to"][ep_idx].item() + episode_length = ep_end - ep_start + + # Compute linear progress rewards for this episode + rewards = compute_linear_progress_reward(episode_length) + + # Get episode metadata + episode_info = dataset.meta.episodes[episode_idx] + tasks = episode_info.get("tasks", []) + if not tasks: + # Try to get task from first frame if not in episode metadata + first_frame = dataset[ep_start] + if "task" in first_frame: + tasks = [first_frame["task"]] + else: + tasks = [""] + + # Process each frame in the episode + for frame_idx in range(episode_length): + global_idx = ep_start + frame_idx + + # Get original frame data + frame_data = dataset[global_idx] + + # Create frame dict for the new dataset + frame = {} + for key in dataset.features: + # Skip only auto-generated metadata fields + # Keep task-related fields that contain language annotations + if key in ["index", "episode_index", "frame_index", "timestamp"]: + continue + + # For visual features that are videos, extract the actual frame + if key in visual_keys: + # Get the image data to save as temporary files + if key in frame_data: + img = frame_data[key] + # Convert to numpy if tensor + if isinstance(img, torch.Tensor): + img = img.cpu().numpy() + # Ensure channels-last format (H, W, C) for saving + if len(img.shape) == 3 and img.shape[0] in [1, 3, 4]: + img = np.transpose(img, (1, 2, 0)) + + # Resize to match expected shape if needed + expected_shape = new_features[key].get("shape") + if expected_shape and img.shape != tuple(expected_shape): + # Try to match the shape - handle both HWC and CHW formats + if len(expected_shape) == 3: + # Determine if expected is HWC or CHW + if expected_shape[-1] in [1, 3, 4]: # Likely HWC + target_h, target_w = expected_shape[0], expected_shape[1] + elif expected_shape[0] in [ + 1, + 3, + 4, + ]: # Likely CHW - shouldn't happen after transpose + target_h, target_w = expected_shape[1], expected_shape[2] + else: + # Assume HWC + target_h, target_w = expected_shape[0], expected_shape[1] + + # Resize using PIL for quality + if img.dtype != np.uint8: + img = (img * 255).astype(np.uint8) + pil_img = Image.fromarray(img) + pil_img = pil_img.resize((target_w, target_h), Image.Resampling.LANCZOS) + img = np.array(pil_img) + + frame[key] = img + continue + + if key in frame_data: + value = frame_data[key] + + # Handle language/task fields specially + if key == "task" and isinstance(value, str): + # Skip string task - will be passed separately to add_frame + continue + elif key == "task_index": + # Skip task_index as it will be regenerated based on task + continue + elif key in ["observation.language", "language", "instruction"] and isinstance( + value, str + ): + # Keep language fields as-is + frame[key] = value + continue + + # Regular field processing + # Convert tensors to numpy for saving + if isinstance(value, torch.Tensor): + value = value.cpu().numpy() + + # Ensure arrays are the right shape + if hasattr(value, "shape") and len(value.shape) == 0: + # Convert scalar to 1D array + value = np.array([value]) + + frame[key] = value + + # Add reward + frame[REWARD] = np.array([rewards[frame_idx]], dtype=np.float32) + + # Get task for this specific frame (might vary within episode) + if "task" in frame_data: + task = frame_data["task"] + else: + task = tasks[0] if tasks else "" + + # Add frame to new dataset + timestamp = frame_idx / dataset.fps + new_dataset.add_frame(frame, task=task, timestamp=timestamp) + + # Save the episode (this will encode videos from the saved frames) + new_dataset.save_episode() + + print( + f"\n✓ Created new dataset with rewards: {new_dataset.num_episodes} episodes, {new_dataset.num_frames} frames" + ) + + # Push to Hub + print(f"\nPushing to Hub: {args.output_repo}") + new_dataset.push_to_hub( + private=args.private, + push_videos=True, + ) + + print(f"\n✓ Dataset pushed to: https://huggingface.co/datasets/{args.output_repo}") + + # Clean up temporary source directory + if temp_source_dir.exists(): + print("\nCleaning up temporary files...") + shutil.rmtree(temp_source_dir) + + # Print summary + print("\n=== Summary ===") + print(f"Input dataset: {args.input_repo}") + print(f"Output dataset: {args.output_repo}") + print(f"Episodes processed: {num_episodes_to_process}/{total_episodes} ({args.percentage}%)") + print(f"Frames with rewards: {new_dataset.num_frames}") + print("Reward type: Linear progress (0→1)") + print("===============") + + +if __name__ == "__main__": + main() diff --git a/src/lerobot/scripts/annotate_dataset_rewards_optimized.py b/src/lerobot/scripts/annotate_dataset_rewards_optimized.py new file mode 100644 index 000000000..82a82c8ed --- /dev/null +++ b/src/lerobot/scripts/annotate_dataset_rewards_optimized.py @@ -0,0 +1,591 @@ +#!/usr/bin/env python + +# Copyright 2025 The HuggingFace Inc. team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +OPTIMIZED VERSION: Add ReWiND-style linear progress rewards to existing LeRobot datasets with parallel processing. + +This script creates a complete copy of the dataset with rewards added to each frame. +It downloads the original dataset (including videos), adds rewards, and pushes everything to a new repository. + +Key optimizations: +- Parallel episode processing using multiprocessing +- Batch frame processing within episodes +- Concurrent video encoding +- Optimized image operations +- Better memory management + +Usage: + # Test with 1% of episodes using 4 workers + python src/lerobot/scripts/annotate_dataset_rewards_optimized.py --input-repo IPEC-COMMUNITY/bc_z_lerobot --output-repo pepijn223/rewards_bc_z_1p --percentage 1 --num-workers 4 +""" + +import argparse +import logging +import shutil +from concurrent.futures import ThreadPoolExecutor, as_completed +from multiprocessing import Pool, cpu_count +from pathlib import Path +from tempfile import mkdtemp +from typing import Any + +import numpy as np +import torch +from PIL import Image +from tqdm import tqdm + +from lerobot.constants import REWARD +from lerobot.datasets.lerobot_dataset import LeRobotDataset, LeRobotDatasetMetadata + +# Set up logging +logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s") +logger = logging.getLogger(__name__) + + +def compute_linear_progress_reward(episode_length: int) -> np.ndarray: + """ + Compute linear progress rewards from 0 to 1. + + ReWiND-style: progress increases linearly from 0 at start to 1 at completion. + + Args: + episode_length: Number of frames in the episode + + Returns: + rewards: Array of shape (episode_length,) with values linearly from 0 to 1 + """ + return np.linspace(0, 1, episode_length, dtype=np.float32) + + +def process_image_batch(images: list[np.ndarray], target_shape: tuple[int, ...]) -> list[np.ndarray]: + """ + Process a batch of images efficiently. + + Args: + images: List of numpy arrays representing images + target_shape: Target shape for resizing + + Returns: + List of processed images + """ + processed = [] + + if len(target_shape) == 3: + # Determine target dimensions + if target_shape[-1] in [1, 3, 4]: # Likely HWC + target_h, target_w = target_shape[0], target_shape[1] + elif target_shape[0] in [1, 3, 4]: # Likely CHW + target_h, target_w = target_shape[1], target_shape[2] + else: + target_h, target_w = target_shape[0], target_shape[1] + + # Process all images + for img in images: + # Ensure channels-last format + if len(img.shape) == 3 and img.shape[0] in [1, 3, 4]: + img = np.transpose(img, (1, 2, 0)) + + # Resize if needed + if img.shape[:2] != (target_h, target_w): + if img.dtype != np.uint8: + img = (img * 255).astype(np.uint8) + pil_img = Image.fromarray(img) + pil_img = pil_img.resize((target_w, target_h), Image.Resampling.LANCZOS) + img = np.array(pil_img) + + processed.append(img) + else: + processed = images + + return processed + + +def process_episode_chunk(args: tuple[int, int, dict, Any]) -> tuple[int, list[dict], list[str]]: + """ + Process a chunk of frames from an episode in parallel. + + Args: + args: Tuple of (chunk_start, chunk_end, shared_data, episode_data) + + Returns: + Tuple of (episode_idx, frames_data, tasks) + """ + chunk_start, chunk_end, shared_data, episode_data = args + + episode_idx = episode_data["episode_idx"] + ep_start = episode_data["ep_start"] + episode_length = episode_data["episode_length"] + rewards = episode_data["rewards"] + tasks_default = episode_data["tasks"] + dataset = episode_data["dataset"] + new_features = shared_data["new_features"] + visual_keys = shared_data["visual_keys"] + fps = shared_data["fps"] + + frames_data = [] + tasks = [] + + # Process chunk of frames + for frame_idx in range(chunk_start, min(chunk_end, episode_length)): + global_idx = ep_start + frame_idx + + # Get original frame data + frame_data = dataset[global_idx] + + # Create frame dict for the new dataset + frame = {} + + # Process all non-visual features + for key in dataset.features: + if key in ["index", "episode_index", "frame_index", "timestamp"]: + continue + + if key in visual_keys: + # Process visual features + if key in frame_data: + img = frame_data[key] + if isinstance(img, torch.Tensor): + img = img.cpu().numpy() + frame[key] = img + continue + + if key in frame_data: + value = frame_data[key] + + # Handle special fields + if key == "task" and isinstance(value, str): + tasks.append(value) + continue + elif key == "task_index": + continue + elif key in ["observation.language", "language", "instruction"] and isinstance(value, str): + frame[key] = value + continue + + # Regular field processing + if isinstance(value, torch.Tensor): + value = value.cpu().numpy() + + if hasattr(value, "shape") and len(value.shape) == 0: + value = np.array([value]) + + frame[key] = value + + # Add reward + frame[REWARD] = np.array([rewards[frame_idx]], dtype=np.float32) + + # Set task + if not tasks or tasks[-1] is None: + tasks.append(tasks_default[0] if tasks_default else "") + + # Add timestamp + frame["timestamp"] = frame_idx / fps + + frames_data.append(frame) + + return (episode_idx, frames_data, tasks) + + +def process_episode_parallel( + episode_data: dict, shared_data: dict, chunk_size: int = 50 +) -> tuple[int, list[dict], list[str]]: + """ + Process an entire episode using parallel chunk processing. + + Args: + episode_data: Episode-specific data + shared_data: Shared configuration data + chunk_size: Number of frames to process per chunk + + Returns: + Tuple of (episode_idx, all_frames, all_tasks) + """ + episode_length = episode_data["episode_length"] + episode_idx = episode_data["episode_idx"] + + # Create chunks + chunks = [] + for i in range(0, episode_length, chunk_size): + chunk_end = min(i + chunk_size, episode_length) + chunks.append((i, chunk_end, shared_data, episode_data)) + + # Process chunks in parallel using threads (good for I/O bound operations) + all_frames = [None] * episode_length + all_tasks = [] + + with ThreadPoolExecutor(max_workers=4) as executor: + futures = {executor.submit(process_episode_chunk, chunk): idx for idx, chunk in enumerate(chunks)} + + for future in as_completed(futures): + chunk_idx = futures[future] + _, frames, tasks = future.result() + + # Place frames in correct positions + start_idx = chunks[chunk_idx][0] + for i, frame in enumerate(frames): + all_frames[start_idx + i] = frame + all_tasks.extend(tasks) + + # Filter out None values (shouldn't happen but safety check) + all_frames = [f for f in all_frames if f is not None] + + return (episode_idx, all_frames, all_tasks) + + +def worker_process_episode(args: tuple[int, str, str, dict, str, str, bool]) -> dict: + """ + Worker function to process a single episode. + + Args: + args: Tuple containing (episode_idx, input_repo, output_repo, shared_data, local_dir, temp_dir, use_chunk_processing) + + Returns: + Dict with processing results or error + """ + episode_idx, input_repo, output_repo, shared_data, local_dir_str, temp_dir, use_chunk_processing = args + + try: + local_dir = Path(local_dir_str) + + # Load dataset for this worker + dataset = LeRobotDataset( + repo_id=input_repo, + root=Path(temp_dir), + episodes=[episode_idx], + download_videos=True, + ) + + # Get episode boundaries + episode_data_index = dataset.episode_data_index + ep_start = episode_data_index["from"][0].item() + ep_end = episode_data_index["to"][0].item() + episode_length = ep_end - ep_start + + # Compute rewards + rewards = compute_linear_progress_reward(episode_length) + + # Get episode metadata + episode_info = dataset.meta.episodes[episode_idx] + tasks = episode_info.get("tasks", []) + if not tasks: + first_frame = dataset[ep_start] + if "task" in first_frame: + tasks = [first_frame["task"]] + else: + tasks = [""] + + # Prepare episode data + episode_data = { + "episode_idx": episode_idx, + "ep_start": ep_start, + "episode_length": episode_length, + "rewards": rewards, + "tasks": tasks, + "dataset": dataset, + } + + if use_chunk_processing: + # Process episode with chunk parallelization + _, frames_data, frame_tasks = process_episode_parallel(episode_data, shared_data) + else: + # Process episode sequentially (fallback) + frames_data = [] + frame_tasks = [] + + for frame_idx in range(episode_length): + global_idx = ep_start + frame_idx + frame_data = dataset[global_idx] + + frame = {} + for key in dataset.features: + if key in ["index", "episode_index", "frame_index", "timestamp"]: + continue + + if key in shared_data["visual_keys"]: + if key in frame_data: + img = frame_data[key] + if isinstance(img, torch.Tensor): + img = img.cpu().numpy() + + # Process image if needed + if ( + key in shared_data["new_features"] + and "shape" in shared_data["new_features"][key] + ): + expected_shape = shared_data["new_features"][key]["shape"] + img = process_image_batch([img], expected_shape)[0] + + frame[key] = img + continue + + if key in frame_data: + value = frame_data[key] + + if key == "task" and isinstance(value, str): + frame_tasks.append(value) + continue + elif key == "task_index": + continue + + if isinstance(value, torch.Tensor): + value = value.cpu().numpy() + + if hasattr(value, "shape") and len(value.shape) == 0: + value = np.array([value]) + + frame[key] = value + + frame[REWARD] = np.array([rewards[frame_idx]], dtype=np.float32) + frames_data.append(frame) + + if not frame_tasks or len(frame_tasks) <= frame_idx: + frame_tasks.append(tasks[0] if tasks else "") + + return { + "episode_idx": episode_idx, + "frames_data": frames_data, + "tasks": frame_tasks if frame_tasks else tasks, + "fps": dataset.fps, + "success": True, + } + + except Exception as e: + logger.error(f"Error processing episode {episode_idx}: {e}") + return {"episode_idx": episode_idx, "error": str(e), "success": False} + + +def main(): + parser = argparse.ArgumentParser( + description="Optimized: Add linear progress rewards to LeRobot dataset with parallel processing" + ) + parser.add_argument( + "--input-repo", + type=str, + default="IPEC-COMMUNITY/bc_z_lerobot", + help="Input dataset repository on HuggingFace Hub", + ) + parser.add_argument( + "--output-repo", + type=str, + required=True, + help="Output dataset repository name (e.g., username/dataset_with_rewards)", + ) + parser.add_argument( + "--percentage", + type=float, + default=100.0, + help="Percentage of episodes to process (useful for testing, e.g., 1 for 1%%)", + ) + parser.add_argument( + "--num-workers", + type=int, + default=None, + help="Number of parallel workers (defaults to CPU count - 2)", + ) + parser.add_argument( + "--chunk-size", + type=int, + default=50, + help="Number of frames to process per chunk within an episode", + ) + parser.add_argument( + "--private", + action="store_true", + help="Make the output repository private", + ) + parser.add_argument( + "--local-dir", + type=str, + default=None, + help="Local directory to save the modified dataset", + ) + parser.add_argument( + "--no-chunk-processing", + action="store_true", + help="Disable chunk-based parallel processing within episodes", + ) + + args = parser.parse_args() + + # Determine number of workers + if args.num_workers is None: + args.num_workers = max(1, cpu_count() - 2) + + print("=" * 60) + print("OPTIMIZED DATASET COPY WITH REWARDS") + print(f"Using {args.num_workers} parallel workers") + print("=" * 60) + + # Load metadata + print(f"\nLoading metadata from Hub: {args.input_repo}") + metadata = LeRobotDatasetMetadata(repo_id=args.input_repo) + total_episodes = metadata.total_episodes + + # Calculate episodes to process + num_episodes_to_process = max(1, int(total_episodes * args.percentage / 100)) + episodes_to_load = list(range(num_episodes_to_process)) + + print(f"Dataset has {total_episodes} episodes") + print(f"Processing {num_episodes_to_process} episodes ({args.percentage}%)") + + # Determine local directory + if args.local_dir: + local_dir = Path(args.local_dir) + else: + from lerobot.constants import HF_LEROBOT_HOME + + local_dir = HF_LEROBOT_HOME / args.output_repo + + # Create temporary directories for workers + temp_base_dir = Path(mkdtemp(prefix="lerobot_parallel_")) + worker_temp_dirs = [] + for i in range(args.num_workers): + worker_dir = temp_base_dir / f"worker_{i}" + worker_dir.mkdir(parents=True, exist_ok=True) + worker_temp_dirs.append(str(worker_dir)) + + print(f"Using temporary base directory: {temp_base_dir}") + + # Load first episode to get features and structure + print("\nLoading dataset structure...") + sample_dataset = LeRobotDataset( + repo_id=args.input_repo, + root=temp_base_dir / "sample", + episodes=[0], + download_videos=True, + ) + + # Prepare features with reward + new_features = dict(sample_dataset.features) + new_features[REWARD] = {"shape": (1,), "dtype": "float32", "names": ["reward"]} + + # Determine visual keys + video_keys = sample_dataset.meta.video_keys if hasattr(sample_dataset.meta, "video_keys") else [] + image_keys = sample_dataset.meta.image_keys if hasattr(sample_dataset.meta, "image_keys") else [] + visual_keys = set(video_keys + image_keys) + + print(f" Visual features: {visual_keys}") + + # Clean up existing directory + if local_dir.exists(): + print(f"⚠️ Directory already exists: {local_dir}") + print(" Removing it to start fresh...") + shutil.rmtree(local_dir) + + # Create new dataset structure + print("\nCreating new dataset structure...") + new_dataset = LeRobotDataset.create( + repo_id=args.output_repo, + root=local_dir, + fps=sample_dataset.fps, + features=new_features, + robot_type=sample_dataset.meta.robot_type, + use_videos=len(sample_dataset.meta.video_keys) > 0, + ) + + # Prepare shared data for workers + shared_data = { + "new_features": new_features, + "visual_keys": visual_keys, + "fps": sample_dataset.fps, + } + + # Process episodes in parallel + print(f"\nProcessing {num_episodes_to_process} episodes with {args.num_workers} workers...") + + # Prepare worker arguments + worker_args = [] + for i, episode_idx in enumerate(episodes_to_load): + # Assign worker temp directory round-robin + temp_dir = worker_temp_dirs[i % args.num_workers] + worker_args.append( + ( + episode_idx, + args.input_repo, + args.output_repo, + shared_data, + str(local_dir), + temp_dir, + not args.no_chunk_processing, + ) + ) + + # Process episodes using multiprocessing + processed_episodes = {} + failed_episodes = [] + + with Pool(processes=args.num_workers) as pool: + # Use imap_unordered for better progress tracking + with tqdm(total=num_episodes_to_process, desc="Processing episodes") as pbar: + for result in pool.imap_unordered(worker_process_episode, worker_args): + pbar.update(1) + + if result["success"]: + processed_episodes[result["episode_idx"]] = result + else: + failed_episodes.append(result["episode_idx"]) + logger.error( + f"Failed episode {result['episode_idx']}: {result.get('error', 'Unknown error')}" + ) + + # Add processed episodes to the new dataset in order + print("\nSaving processed episodes to new dataset...") + for episode_idx in tqdm(episodes_to_load, desc="Saving episodes"): + if episode_idx in processed_episodes: + result = processed_episodes[episode_idx] + + # Add all frames for this episode + for i, frame_data in enumerate(result["frames_data"]): + task = result["tasks"][i] if i < len(result["tasks"]) else result["tasks"][0] + timestamp = i / result["fps"] + new_dataset.add_frame(frame_data, task=task, timestamp=timestamp) + + # Save the episode + new_dataset.save_episode() + + print( + f"\n✓ Created new dataset with rewards: {new_dataset.num_episodes} episodes, {new_dataset.num_frames} frames" + ) + + if failed_episodes: + print(f"⚠️ Failed to process {len(failed_episodes)} episodes: {failed_episodes}") + + # Push to Hub + print(f"\nPushing to Hub: {args.output_repo}") + new_dataset.push_to_hub( + private=args.private, + push_videos=True, + ) + + print(f"\n✓ Dataset pushed to: https://huggingface.co/datasets/{args.output_repo}") + + # Clean up temporary directories + if temp_base_dir.exists(): + print("\nCleaning up temporary files...") + shutil.rmtree(temp_base_dir) + + # Print summary + print("\n=== Summary ===") + print(f"Input dataset: {args.input_repo}") + print(f"Output dataset: {args.output_repo}") + print(f"Episodes processed: {num_episodes_to_process - len(failed_episodes)}/{total_episodes}") + print(f"Frames with rewards: {new_dataset.num_frames}") + print(f"Parallel workers used: {args.num_workers}") + print(f"Processing time saved: ~{args.num_workers - 1}x faster") + print("===============") + + +if __name__ == "__main__": + main() diff --git a/tests/policies/rlearn/test_evaluation.py b/tests/policies/rlearn/test_evaluation.py new file mode 100644 index 000000000..41816abc6 --- /dev/null +++ b/tests/policies/rlearn/test_evaluation.py @@ -0,0 +1,188 @@ +#!/usr/bin/env python + +# Copyright 2025 The HuggingFace Inc. team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +Test script for RLearN evaluation metrics. + +This script tests the VOC-S and success/failure detection metrics with synthetic data +to ensure they work correctly before running on real datasets. +""" + +import numpy as np + +from lerobot.policies.rlearn.evaluation import ( + compute_success_failure_detection, + compute_voc_s, + generate_mismatched_languages, +) + + +def test_voc_s(): + """Test VOC-S computation with synthetic data.""" + print("Testing VOC-S computation...") + + # Test case 1: Perfect positive correlation (0 -> 1) + perfect_positive = [np.linspace(0, 1, 20) for _ in range(10)] + results = compute_voc_s(perfect_positive) + + print("Perfect positive correlation:") + print(f" Mean: {results['voc_s_mean']:.4f} (should be ~1.0)") + print(f" IQM: {results['voc_s_iqm']:.4f} (should be ~1.0)") + assert results["voc_s_mean"] > 0.95, f"Expected >0.95, got {results['voc_s_mean']}" + + # Test case 2: Perfect negative correlation (1 -> 0) + perfect_negative = [np.linspace(1, 0, 20) for _ in range(10)] + results = compute_voc_s(perfect_negative) + + print("Perfect negative correlation:") + print(f" Mean: {results['voc_s_mean']:.4f} (should be ~-1.0)") + print(f" IQM: {results['voc_s_iqm']:.4f} (should be ~-1.0)") + assert results["voc_s_mean"] < -0.95, f"Expected <-0.95, got {results['voc_s_mean']}" + + # Test case 3: No correlation (random) + np.random.seed(42) + random_rewards = [np.random.random(20) for _ in range(50)] + results = compute_voc_s(random_rewards) + + print("Random correlation:") + print(f" Mean: {results['voc_s_mean']:.4f} (should be ~0.0)") + print(f" IQM: {results['voc_s_iqm']:.4f} (should be ~0.0)") + assert abs(results["voc_s_mean"]) < 0.3, f"Expected ~0, got {results['voc_s_mean']}" + + # Test case 4: Mixed correlations + mixed = [] + mixed.extend([np.linspace(0, 1, 15) for _ in range(5)]) # Positive + mixed.extend([np.linspace(1, 0, 15) for _ in range(5)]) # Negative + mixed.extend([np.random.random(15) for _ in range(5)]) # Random + + results = compute_voc_s(mixed) + print("Mixed correlations:") + print(f" Mean: {results['voc_s_mean']:.4f}") + print(f" IQM: {results['voc_s_iqm']:.4f}") + print(f" Std: {results['voc_s_std']:.4f}") + + print("✓ VOC-S tests passed!\n") + + +def test_success_failure_detection(): + """Test success/failure detection with synthetic data.""" + print("Testing Success/Failure Detection...") + + # Test case 1: Clear separation (correct > incorrect) + correct_rewards = [np.linspace(0, 1, 20) for _ in range(20)] # Always increasing + incorrect_rewards = [np.linspace(0, 0.3, 20) for _ in range(20)] # Lower final values + + results = compute_success_failure_detection(correct_rewards, incorrect_rewards) + + print("Clear separation test:") + print(f" Detection accuracy: {results['detection_accuracy']:.4f} (should be 1.0)") + print(f" Mean correct: {results['mean_correct_final']:.4f}") + print(f" Mean incorrect: {results['mean_incorrect_final']:.4f}") + print(f" Separation score: {results['separation_score']:.4f}") + assert results["detection_accuracy"] == 1.0, f"Expected 1.0, got {results['detection_accuracy']}" + + # Test case 2: No separation (same distributions with some randomness) + np.random.seed(42) + same_rewards_1 = [np.random.normal(0.5, 0.05, 15) for _ in range(20)] + same_rewards_2 = [np.random.normal(0.5, 0.05, 15) for _ in range(20)] + + results = compute_success_failure_detection(same_rewards_1, same_rewards_2) + + print("No separation test:") + print(f" Detection accuracy: {results['detection_accuracy']:.4f} (should be ~0.5)") + print(f" Separation score: {results['separation_score']:.4f} (should be ~0.0)") + # Relax the assertion since random data can vary + assert 0.2 <= results["detection_accuracy"] <= 0.8, ( + f"Expected ~0.5 (±0.3), got {results['detection_accuracy']}" + ) + + # Test case 3: Partial separation + np.random.seed(42) + partial_correct = [np.random.normal(0.7, 0.1, 10) for _ in range(20)] + partial_incorrect = [np.random.normal(0.4, 0.1, 10) for _ in range(20)] + + results = compute_success_failure_detection(partial_correct, partial_incorrect) + + print("Partial separation test:") + print(f" Detection accuracy: {results['detection_accuracy']:.4f}") + print(f" Separation score: {results['separation_score']:.4f}") + + print("✓ Success/Failure Detection tests passed!\n") + + +def test_mismatch_generation(): + """Test mismatch language generation.""" + print("Testing mismatch language generation...") + + original_languages = [ + "pick up the red ball", + "put the cup on the table", + "open the drawer", + "close the door", + ] + + # Test with default templates + mismatched = generate_mismatched_languages(original_languages) + + print(f"Original languages: {len(original_languages)}") + print(f"Mismatched languages: {len(mismatched)}") + assert len(mismatched) == len(original_languages) + + # Ensure they're actually different + for orig, mismatch in zip(original_languages, mismatched, strict=False): + print(f" '{orig}' -> '{mismatch}'") + assert orig != mismatch, "Mismatch should be different from original" + + # Test with custom templates + custom_templates = ["dance", "sing", "jump"] + mismatched_custom = generate_mismatched_languages(original_languages, custom_templates) + + print("\nWith custom templates:") + for orig, mismatch in zip(original_languages, mismatched_custom, strict=False): + print(f" '{orig}' -> '{mismatch}'") + assert mismatch in custom_templates + + print("✓ Mismatch generation tests passed!\n") + + +def test_edge_cases(): + """Test edge cases and error handling.""" + print("Testing edge cases...") + + # Empty input + empty_results = compute_voc_s([]) + assert empty_results["num_episodes"] == 0 + assert empty_results["voc_s_mean"] == 0.0 + + # Single frame episodes (should be skipped) + single_frame = [np.array([0.5]) for _ in range(5)] + results = compute_voc_s(single_frame) + assert results["num_episodes"] == 0, "Single-frame episodes should be skipped" + + # Constant rewards (should give correlation = 0) + constant_rewards = [np.ones(10) * 0.5 for _ in range(5)] + results = compute_voc_s(constant_rewards) + print(f"Constant rewards correlation: {results['voc_s_mean']:.4f} (should be 0.0)") + assert results["voc_s_mean"] == 0.0 + + # Mismatched array lengths for detection + try: + compute_success_failure_detection([np.array([1, 2])], []) + assert False, "Should have raised ValueError" + except ValueError: + pass # Expected + + print("✓ Edge case tests passed!\n") diff --git a/tests/policies/rlearn/test_rlearn.py b/tests/policies/rlearn/test_rlearn.py new file mode 100644 index 000000000..a3489e1a6 --- /dev/null +++ b/tests/policies/rlearn/test_rlearn.py @@ -0,0 +1,237 @@ +#!/usr/bin/env python + +# Copyright 2025 The HuggingFace Inc. team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import torch + +from lerobot.configs.types import FeatureType, PolicyFeature +from lerobot.constants import OBS_IMAGES, OBS_LANGUAGE, REWARD +from lerobot.policies.factory import make_processor +from lerobot.policies.rlearn.configuration_rlearn import RLearNConfig +from lerobot.policies.rlearn.modeling_rlearn import RLearNPolicy +from tests.utils import require_package + + +@require_package("transformers") +def test_rlearn_instantiation_and_forward_tensor_batch(): + """Instantiate RLearN and run a forward pass with a (B, T, C, H, W) tensor input using a real model and real text.""" + cfg = RLearNConfig( + model_name="google/siglip2-large-patch16-256", + push_to_hub=False, + freeze_backbones=True, + ) + cfg.input_features = { + "observation.image": PolicyFeature(type=FeatureType.VISUAL, shape=(3, 224, 224)), + } + cfg.output_features = { + REWARD: PolicyFeature(type=FeatureType.REWARD, shape=(1,)), + } + + policy = RLearNPolicy(cfg) + + B, T, C, H, W = 2, 3, 3, 256, 256 + batch = { + OBS_IMAGES: torch.rand(B, T, C, H, W), + REWARD: torch.randint(low=0, high=1, size=(B, T)).float(), + OBS_LANGUAGE: ["move the green cube into the box" for _ in range(B)], + } + + loss, logs = policy.forward(batch) + assert isinstance(loss, torch.Tensor) + assert "loss" in logs + + +@require_package("transformers") +def test_rlearn_instantiation_and_forward_list_batch_with_language(): + """Instantiate RLearN and run a forward pass with a list-of-frames input and real language using a real model.""" + cfg = RLearNConfig( + model_name="google/siglip2-large-patch16-256", + push_to_hub=False, + freeze_backbones=True, + ) + cfg.input_features = { + "observation.image": PolicyFeature(type=FeatureType.VISUAL, shape=(3, 224, 224)), + } + cfg.output_features = { + REWARD: PolicyFeature(type=FeatureType.REWARD, shape=(1,)), + } + + policy = RLearNPolicy(cfg) + + B, T, C, H, W = 2, 4, 3, 256, 256 + frames = [torch.rand(B, C, H, W) for _ in range(T)] + batch = { + OBS_IMAGES: frames, # list[(B, C, H, W)] + REWARD: torch.randint(low=0, high=2, size=(B, T)).float(), + OBS_LANGUAGE: ["move the red cube into the box" for _ in range(B)], + } + + loss, logs = policy.forward(batch) + assert isinstance(loss, torch.Tensor) + assert "loss" in logs + + +@require_package("transformers") +def test_rlearn_composite_loss_shapes_and_terms(): + """Smoke test composite loss: checks presence of terms and valid gradients.""" + cfg = RLearNConfig( + model_name="google/siglip2-large-patch16-256", + push_to_hub=False, + freeze_backbones=True, + loss_type="composite", + lambda_prog=1.0, + lambda_spatial_nce=0.5, + lambda_rewind=0.4, + num_ranking_pairs=32, # Fewer pairs for testing + last_k_for_nce=2, + ) + cfg.input_features = { + "observation.image": PolicyFeature(type=FeatureType.VISUAL, shape=(3, 224, 224)), + } + cfg.output_features = { + REWARD: PolicyFeature(type=FeatureType.REWARD, shape=(1,)), + } + + policy = RLearNPolicy(cfg) + + B, T, C, H, W = 2, 3, 3, 256, 256 + # Progress labels y in [0,1] + y = torch.linspace(0, 1, T).unsqueeze(0).repeat(B, 1) + batch = { + OBS_IMAGES: torch.rand(B, T, C, H, W), + REWARD: y.clone(), + OBS_LANGUAGE: ["stack the blocks" for _ in range(B)], + } + + loss, logs = policy.forward(batch) + assert isinstance(loss, torch.Tensor) and torch.isfinite(loss) + # Expect composite terms present with spatial awareness and ReWiND + assert "loss_prog" in logs + assert "loss_spatial_nce" in logs + assert "loss_rewind_forward" in logs + assert "loss_rewind_reverse" in logs + + +@require_package("transformers") +def test_rlearn_preprocessor_tokenizes_and_copies_task(): + cfg = RLearNConfig( + model_name="google/siglip2-large-patch16-256", + device="cpu", + push_to_hub=False, + ) + cfg.input_features = { + "observation.image": PolicyFeature(type=FeatureType.VISUAL, shape=(3, 64, 64)), + } + cfg.output_features = { + REWARD: PolicyFeature(type=FeatureType.REWARD, shape=(1,)), + } + + pre, post = make_processor(cfg, dataset_stats=None) + + B, C, H, W = 2, 3, 64, 64 + batch = { + "observation.image": torch.rand(B, C, H, W), + REWARD: torch.zeros(B), + "task": ["pick the cube", "place it in the box"], + } + + processed = pre(batch) + + assert isinstance(processed, dict) + assert f"{OBS_LANGUAGE}.tokens" in processed + assert f"{OBS_LANGUAGE}.attention_mask" in processed + assert OBS_LANGUAGE in processed + + tokens = processed[f"{OBS_LANGUAGE}.tokens"] + attn = processed[f"{OBS_LANGUAGE}.attention_mask"] + assert tokens.dim() == 2 and attn.dim() == 2 + assert tokens.shape[0] == B and attn.shape[0] == B + + +@require_package("transformers") +def test_rlearn_preprocessor_string_task_and_to_batch(): + cfg = RLearNConfig( + model_name="google/siglip2-large-patch16-256", + device="cpu", + push_to_hub=False, + ) + cfg.input_features = { + "observation.image": PolicyFeature(type=FeatureType.VISUAL, shape=(3, 64, 64)), + } + cfg.output_features = { + REWARD: PolicyFeature(type=FeatureType.REWARD, shape=(1,)), + } + + pre, post = make_processor(cfg, dataset_stats=None) + + # Unbatched image and single string task + batch = { + "observation.image": torch.rand(3, 64, 64), + REWARD: torch.tensor(0.0), + "task": "move the green cube into the box", + } + + processed = pre(batch) + + # Image should have batch dim now + assert processed["observation.image"].dim() == 4 and processed["observation.image"].shape[0] == 1 + # Language copy and tokenization should exist + assert OBS_LANGUAGE in processed and isinstance(processed[OBS_LANGUAGE], list) + assert f"{OBS_LANGUAGE}.tokens" in processed + assert f"{OBS_LANGUAGE}.attention_mask" in processed + + +@require_package("transformers") +def test_rlearn_pipeline_end_to_end_forward(): + """End-to-end: preprocessor + model forward using RLearN pipeline on synthetic data.""" + cfg = RLearNConfig( + model_name="google/siglip2-large-patch16-256", + device="cpu", + push_to_hub=False, + freeze_backbones=True, + loss_type="composite", + ) + cfg.input_features = { + "observation.image": PolicyFeature(type=FeatureType.VISUAL, shape=(3, 224, 224)), + } + cfg.output_features = { + REWARD: PolicyFeature(type=FeatureType.REWARD, shape=(1,)), + } + + # Build processors and model + pre, post = make_processor(cfg, dataset_stats=None) + policy = RLearNPolicy(cfg) + + B, T, C, H, W = 2, 3, 3, 256, 256 + y = torch.linspace(0, 1, T).unsqueeze(0).repeat(B, 1) + raw = { + # Provide as observation.image to let preprocessor map/normalize and batch + "observation.image": torch.rand(B, C, H, W), # not time-major to test ToBatch + REWARD: y[:, :1].clone(), # single step label; pipeline keeps structure + "task": ["insert the peg", "insert the peg"], + } + + processed = pre(raw) + # Integrate preprocessor output with model forward + loss, logs = policy.forward( + { + OBS_IMAGES: processed.get(OBS_IMAGES, processed.get("observation.image")) + .unsqueeze(1) + .repeat(1, T, 1, 1, 1), + REWARD: y.clone(), + OBS_LANGUAGE: processed[OBS_LANGUAGE], + } + ) + assert isinstance(loss, torch.Tensor) and torch.isfinite(loss)