diff --git a/Drone Navigation Detection using Reinforcement Learning techniques/Dataset/Dataset- Explanations b/Drone Navigation Detection using Reinforcement Learning techniques/Dataset/Dataset- Explanations
new file mode 100644
index 000000000..93df705a2
--- /dev/null
+++ b/Drone Navigation Detection using Reinforcement Learning techniques/Dataset/Dataset- Explanations	
@@ -0,0 +1,53 @@
+Detailed Description of the Dataset for Drone Navigation Project
+1. Environment State Representation
+The environment for the drone navigation task is modeled as a 2D grid (10x10) where each cell can represent different types of entities that the drone interacts with. The key components are:
+
+Free Space: This represents areas of the grid where the drone can move freely. Free space cells are the navigable areas where the drone does not encounter any obstacles.
+
+Obstacles: These are fixed points on the grid that the drone must avoid to prevent collisions. In this project, obstacles are defined as specific coordinates:
+
+Example:
+Obstacle 1: (6, 6)
+Obstacle 2: (7, 7)
+Target: This is the desired destination that the drone aims to reach. The target position is critical for the navigation algorithm to determine successful completion of the task.
+
+Example:
+Target Position: (8, 8)
+2. State Space
+The state of the drone is represented using a 2D NumPy array with two elements, denoting the drone's current position on the grid:
+
+state[0]: Represents the x-coordinate (horizontal position) of the drone.
+state[1]: Represents the y-coordinate (vertical position) of the drone.
+The observation space is defined within the bounds of the grid, specifically from 0 to 10. This range indicates that the drone's movements and positions are confined within a 10x10 grid.
+
+3. Action Space
+The available actions for the drone are discrete movements within the grid. Each action corresponds to a direction the drone can move:
+
+0: Up (increases y-coordinate)
+1: Down (decreases y-coordinate)
+2: Left (decreases x-coordinate)
+3: Right (increases x-coordinate)
+4: Up-Right (increases both x and y coordinates)
+5: Up-Left (decreases x and increases y coordinates)
+6: Down-Right (increases x and decreases y coordinates)
+7: Down-Left (decreases both x and y coordinates)
+This action space allows for basic directional movements, enabling the drone to navigate towards its target while avoiding obstacles.
+
+4. Sample Data
+While the environment is not reliant on external datasets, the positions of obstacles and the target can be treated as parameters that define the specific scenario of the navigation task. Below are examples of the parameters used in the project:
+
+Initial State: The drone starts at position (5, 5).
+Obstacles: [(6, 6), (7, 7)]
+Target Position: (8, 8)
+This setup allows for a controlled testing environment where various navigation strategies can be implemented and evaluated.
+
+5. Data Generation
+The grid layout, positions of obstacles, and the target location are configurable parameters that can be adjusted to create different scenarios for testing the drone's navigation algorithm. The drone can be tested in various configurations to analyze its performance in navigating towards the target while avoiding collisions.
+
+6. Future Dataset Enhancements
+In future iterations of this project, there are several potential enhancements that can be made to the dataset:
+
+Dynamic Obstacles: Introducing moving obstacles that change positions over time, simulating more realistic navigation challenges.
+Variable Target Locations: Allowing the target position to change during the task to test the drone's adaptability and decision-making.
+Real-World Data: Integrating real-world datasets (such as GPS coordinates or aerial maps) to enhance the environment's complexity and realism.
+Multiple Drones: Expanding the project to include multiple drones navigating the same environment, which could lead to more complex scenarios and interactions.
diff --git a/Drone Navigation Detection using Reinforcement Learning techniques/Dataset/datset_info b/Drone Navigation Detection using Reinforcement Learning techniques/Dataset/datset_info
new file mode 100644
index 000000000..e4a0f577f
--- /dev/null
+++ b/Drone Navigation Detection using Reinforcement Learning techniques/Dataset/datset_info	
@@ -0,0 +1,37 @@
+# Dataset Description for Drone Navigation Project
+
+## Environment State Representation:
+The drone's environment is represented as a 2D grid where each cell can represent different entities:
+- **Free Space**: Areas where the drone can navigate.
+- **Obstacles**: Fixed points on the grid that the drone must avoid.
+  - Example: (6, 6), (7, 7)
+- **Target**: The desired destination for the drone to reach.
+  - Example: (8, 8)
+
+## State Space:
+The state of the drone is represented as a 2D NumPy array with two elements:
+- **state[0]**: The x-coordinate of the drone's current position.
+- **state[1]**: The y-coordinate of the drone's current position.
+
+The observation space is defined within the bounds of the grid, specifically [0, 10], indicating that the drone can move within a 10x10 grid.
+
+## Action Space:
+The actions available to the drone are represented as discrete movements within the grid:
+- **0**: Up
+- **1**: Down
+- **2**: Left
+- **3**: Right
+- **4**: Up-Right
+- **5**: Up-Left
+- **6**: Down-Right
+- **7**: Down-Left
+
+## Sample Data:
+While the environment does not rely on external datasets, the positions of obstacles and the target can be seen as parameters that define the specific scenario of the navigation task.
+
+## Data Generation:
+The grid layout, obstacle positions, and target location can be adjusted as necessary to create various scenarios for testing the drone's navigation algorithm.
+
+## Future Dataset Enhancements:
+Future versions of the project may incorporate more complex environments with variable obstacle positions, dynamic targets, and real-world data, enhancing the robustness and adaptability of the navigation algorithm.
+
diff --git a/Drone Navigation Detection using Reinforcement Learning techniques/Images/3D Path Finding Cost Suraface schematic.png b/Drone Navigation Detection using Reinforcement Learning techniques/Images/3D Path Finding Cost Suraface schematic.png
new file mode 100644
index 000000000..c96a19820
Binary files /dev/null and b/Drone Navigation Detection using Reinforcement Learning techniques/Images/3D Path Finding Cost Suraface schematic.png differ
diff --git a/Drone Navigation Detection using Reinforcement Learning techniques/Images/Drone Nav Graph.png b/Drone Navigation Detection using Reinforcement Learning techniques/Images/Drone Nav Graph.png
new file mode 100644
index 000000000..15d329a6c
Binary files /dev/null and b/Drone Navigation Detection using Reinforcement Learning techniques/Images/Drone Nav Graph.png differ
diff --git a/Drone Navigation Detection using Reinforcement Learning techniques/Images/Drone Navigation Graph.png b/Drone Navigation Detection using Reinforcement Learning techniques/Images/Drone Navigation Graph.png
new file mode 100644
index 000000000..bd9d32aa1
Binary files /dev/null and b/Drone Navigation Detection using Reinforcement Learning techniques/Images/Drone Navigation Graph.png differ
diff --git a/Drone Navigation Detection using Reinforcement Learning techniques/Images/Navigation Graph.png b/Drone Navigation Detection using Reinforcement Learning techniques/Images/Navigation Graph.png
new file mode 100644
index 000000000..4ddd495ac
Binary files /dev/null and b/Drone Navigation Detection using Reinforcement Learning techniques/Images/Navigation Graph.png differ
diff --git a/Drone Navigation Detection using Reinforcement Learning techniques/Images/a star graph.png b/Drone Navigation Detection using Reinforcement Learning techniques/Images/a star graph.png
new file mode 100644
index 000000000..e72027c79
Binary files /dev/null and b/Drone Navigation Detection using Reinforcement Learning techniques/Images/a star graph.png differ
diff --git a/Drone Navigation Detection using Reinforcement Learning techniques/Images/env graph.png b/Drone Navigation Detection using Reinforcement Learning techniques/Images/env graph.png
new file mode 100644
index 000000000..523361e5a
Binary files /dev/null and b/Drone Navigation Detection using Reinforcement Learning techniques/Images/env graph.png differ
diff --git a/Drone Navigation Detection using Reinforcement Learning techniques/Images/img files b/Drone Navigation Detection using Reinforcement Learning techniques/Images/img files
new file mode 100644
index 000000000..8b1378917
--- /dev/null
+++ b/Drone Navigation Detection using Reinforcement Learning techniques/Images/img files	
@@ -0,0 +1 @@
+
diff --git a/Drone Navigation Detection using Reinforcement Learning techniques/Images/pathfinding_heat-map.png b/Drone Navigation Detection using Reinforcement Learning techniques/Images/pathfinding_heat-map.png
new file mode 100644
index 000000000..60dfd0baa
Binary files /dev/null and b/Drone Navigation Detection using Reinforcement Learning techniques/Images/pathfinding_heat-map.png differ
diff --git a/Drone Navigation Detection using Reinforcement Learning techniques/Model/Drone_Navigation_Detection (1).ipynb b/Drone Navigation Detection using Reinforcement Learning techniques/Model/Drone_Navigation_Detection (1).ipynb
new file mode 100644
index 000000000..16554b9bf
--- /dev/null
+++ b/Drone Navigation Detection using Reinforcement Learning techniques/Model/Drone_Navigation_Detection (1).ipynb	
@@ -0,0 +1,935 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Part 1: Custom Drone Navigation Environment**\n",
+        "\n",
+        "This code sets up a custom environment for a drone that can move in 8 possible directions. It uses the Gym framework to manage actions, states, rewards, and termination conditions."
+      ],
+      "metadata": {
+        "id": "o4DN_tEg2jvr"
+      }
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "id": "HEk1YPjS2alK"
+      },
+      "outputs": [],
+      "source": [
+        "import gym\n",
+        "import numpy as np\n",
+        "import random\n",
+        "\n",
+        "# Define a custom environment for drone navigation\n",
+        "class DroneEnv(gym.Env):\n",
+        "    def __init__(self):\n",
+        "        super(DroneEnv, self).__init__()\n",
+        "        self.action_space = gym.spaces.Discrete(8)  # 8 possible actions\n",
+        "        self.observation_space = gym.spaces.Box(low=0, high=10, shape=(2,), dtype=np.float32)\n",
+        "        self.state = np.array([5, 5])  # Start position\n",
+        "        self.target = np.array([8, 8])  # Target position\n",
+        "        self.obstacles = [np.array([6, 6]), np.array([7, 7])]  # Obstacles\n",
+        "        self.epsilon = 0.1  # Exploration rate\n",
+        "\n",
+        "    def reset(self):\n",
+        "        self.state = np.array([5, 5])\n",
+        "        return self.state\n",
+        "\n",
+        "    def step(self, action):\n",
+        "        if random.random() < self.epsilon:  # Exploration\n",
+        "            action = self.action_space.sample()\n",
+        "\n",
+        "        # Define 8-direction movement\n",
+        "        movements = [(0, 1), (0, -1), (-1, 0), (1, 0), (1, 1), (-1, 1), (1, -1), (-1, -1)]\n",
+        "        move = movements[action]\n",
+        "        self.state = np.clip(self.state + move, 0, 10)  # Ensure within bounds\n",
+        "\n",
+        "        # Check for collisions and termination conditions\n",
+        "        reward = -1\n",
+        "        done = False\n",
+        "        if any(np.array_equal(self.state, obs) for obs in self.obstacles):\n",
+        "            reward = -10  # Penalty for hitting an obstacle\n",
+        "            done = True\n",
+        "        elif np.array_equal(self.state, self.target):\n",
+        "            reward = 10  # Reward for reaching the target\n",
+        "            done = True\n",
+        "\n",
+        "        return self.state, reward, done, {}\n",
+        "\n",
+        "    def render(self):\n",
+        "        print(f\"Drone Position: {self.state}, Target: {self.target}, Obstacles: {self.obstacles}\")\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Part 2: A* Pathfinding Algorithm**\n",
+        "The A* pathfinding algorithm helps the drone find an optimal path to the target while avoiding obstacles. This function takes a start position, a goal, obstacles, and grid dimensions as inputs."
+      ],
+      "metadata": {
+        "id": "Grvzyodk2vqP"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import heapq\n",
+        "\n",
+        "# Heuristic function for A* (Euclidean distance)\n",
+        "def heuristic(a, b):\n",
+        "    return np.linalg.norm(np.array(a) - np.array(b))\n",
+        "\n",
+        "# A* pathfinding function\n",
+        "def a_star(start, goal, obstacles, grid_width, grid_height):\n",
+        "    open_set = []\n",
+        "    heapq.heappush(open_set, (0, start))\n",
+        "    came_from = {}\n",
+        "    g_score = {start: 0}\n",
+        "    f_score = {start: heuristic(start, goal)}\n",
+        "\n",
+        "    while open_set:\n",
+        "        current = heapq.heappop(open_set)[1]\n",
+        "\n",
+        "        if current == goal:\n",
+        "            # Reconstruct path from goal to start\n",
+        "            path = []\n",
+        "            while current in came_from:\n",
+        "                path.append(current)\n",
+        "                current = came_from[current]\n",
+        "            return path[::-1]\n",
+        "\n",
+        "        for direction in [(1, 0), (0, 1), (-1, 0), (0, -1)]:\n",
+        "            neighbor = (current[0] + direction[0], current[1] + direction[1])\n",
+        "            if neighbor in obstacles or not (0 <= neighbor[0] < grid_width and 0 <= neighbor[1] < grid_height):\n",
+        "                continue\n",
+        "\n",
+        "            tentative_g_score = g_score[current] + 1\n",
+        "            if neighbor not in g_score or tentative_g_score < g_score[neighbor]:\n",
+        "                came_from[neighbor] = current\n",
+        "                g_score[neighbor] = tentative_g_score\n",
+        "                f_score[neighbor] = tentative_g_score + heuristic(neighbor, goal)\n",
+        "                if neighbor not in [i[1] for i in open_set]:\n",
+        "                    heapq.heappush(open_set, (f_score[neighbor], neighbor))\n",
+        "\n",
+        "    return []  # No path found if the open_set is exhausted\n"
+      ],
+      "metadata": {
+        "id": "gShrXNbi2rzU"
+      },
+      "execution_count": 2,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Part 3: Visualization of the Navigation Graph**\n",
+        "This block uses NetworkX and Matplotlib to visualize waypoints and paths in the navigation graph. Each edge represents a possible route between waypoints, and weights can represent distance or cost."
+      ],
+      "metadata": {
+        "id": "YUdnEH9f27PA"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import networkx as nx\n",
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "# Visualization function for navigation graph\n",
+        "def visualize_graph():\n",
+        "    G = nx.DiGraph()\n",
+        "    G.add_nodes_from([1, 2, 3, 4, 5])\n",
+        "    G.add_edge(1, 2, weight=1.5)\n",
+        "    G.add_edge(1, 3, weight=2.0)\n",
+        "    G.add_edge(2, 4, weight=1.2)\n",
+        "    G.add_edge(3, 4, weight=0.9)\n",
+        "    G.add_edge(4, 5, weight=1.8)\n",
+        "    G.add_edge(3, 5, weight=1.5)\n",
+        "\n",
+        "    # Define layout\n",
+        "    pos = nx.spring_layout(G)\n",
+        "    plt.figure(figsize=(8, 6))\n",
+        "    nx.draw(G, pos, with_labels=True, node_size=700, node_color=\"lightblue\", edge_color=\"gray\", arrows=True)\n",
+        "\n",
+        "    # Annotate with edge weights\n",
+        "    edge_labels = nx.get_edge_attributes(G, 'weight')\n",
+        "    nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_size=10)\n",
+        "    plt.title(\"Drone Navigation Graph\")\n",
+        "    plt.show()\n"
+      ],
+      "metadata": {
+        "id": "ZdfU_8XT24wE"
+      },
+      "execution_count": 3,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Part 4: Reinforcement Learning with PPO**\n",
+        "\n",
+        "We use Stable-Baselines3 to train a PPO model on the custom DroneEnv. The model learns how to navigate the environment and reach the target."
+      ],
+      "metadata": {
+        "id": "QgKGZZGj3FsG"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install stable-baselines3[extra]\n",
+        "from stable_baselines3 import PPO\n",
+        "\n",
+        "# Initialize environment and PPO model\n",
+        "env = DroneEnv()\n",
+        "model = PPO(\"MlpPolicy\", env, verbose=1)\n",
+        "model.learn(total_timesteps=10000)  # Train the model\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "X8DFgdHe3CaC",
+        "outputId": "d64581c2-1172-40d4-be11-93030890bfbf"
+      },
+      "execution_count": 6,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/usr/local/lib/python3.10/dist-packages/ipykernel/ipkernel.py:283: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n",
+            "  and should_run_async(code)\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Collecting stable-baselines3[extra]\n",
+            "  Downloading stable_baselines3-2.3.2-py3-none-any.whl.metadata (5.1 kB)\n",
+            "Collecting gymnasium<0.30,>=0.28.1 (from stable-baselines3[extra])\n",
+            "  Downloading gymnasium-0.29.1-py3-none-any.whl.metadata (10 kB)\n",
+            "Requirement already satisfied: numpy>=1.20 in /usr/local/lib/python3.10/dist-packages (from stable-baselines3[extra]) (1.26.4)\n",
+            "Requirement already satisfied: torch>=1.13 in /usr/local/lib/python3.10/dist-packages (from stable-baselines3[extra]) (2.5.0+cu121)\n",
+            "Requirement already satisfied: cloudpickle in /usr/local/lib/python3.10/dist-packages (from stable-baselines3[extra]) (3.1.0)\n",
+            "Requirement already satisfied: pandas in /usr/local/lib/python3.10/dist-packages (from stable-baselines3[extra]) (2.2.2)\n",
+            "Requirement already satisfied: matplotlib in /usr/local/lib/python3.10/dist-packages (from stable-baselines3[extra]) (3.7.1)\n",
+            "Requirement already satisfied: opencv-python in /usr/local/lib/python3.10/dist-packages (from stable-baselines3[extra]) (4.10.0.84)\n",
+            "Requirement already satisfied: pygame in /usr/local/lib/python3.10/dist-packages (from stable-baselines3[extra]) (2.6.1)\n",
+            "Requirement already satisfied: tensorboard>=2.9.1 in /usr/local/lib/python3.10/dist-packages (from stable-baselines3[extra]) (2.17.0)\n",
+            "Requirement already satisfied: psutil in /usr/local/lib/python3.10/dist-packages (from stable-baselines3[extra]) (5.9.5)\n",
+            "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from stable-baselines3[extra]) (4.66.5)\n",
+            "Requirement already satisfied: rich in /usr/local/lib/python3.10/dist-packages (from stable-baselines3[extra]) (13.9.3)\n",
+            "Collecting shimmy~=1.3.0 (from shimmy[atari]~=1.3.0; extra == \"extra\"->stable-baselines3[extra])\n",
+            "  Downloading Shimmy-1.3.0-py3-none-any.whl.metadata (3.7 kB)\n",
+            "Requirement already satisfied: pillow in /usr/local/lib/python3.10/dist-packages (from stable-baselines3[extra]) (10.4.0)\n",
+            "Collecting autorom~=0.6.1 (from autorom[accept-rom-license]~=0.6.1; extra == \"extra\"->stable-baselines3[extra])\n",
+            "  Downloading AutoROM-0.6.1-py3-none-any.whl.metadata (2.4 kB)\n",
+            "Requirement already satisfied: click in /usr/local/lib/python3.10/dist-packages (from autorom~=0.6.1->autorom[accept-rom-license]~=0.6.1; extra == \"extra\"->stable-baselines3[extra]) (8.1.7)\n",
+            "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from autorom~=0.6.1->autorom[accept-rom-license]~=0.6.1; extra == \"extra\"->stable-baselines3[extra]) (2.32.3)\n",
+            "Collecting AutoROM.accept-rom-license (from autorom[accept-rom-license]~=0.6.1; extra == \"extra\"->stable-baselines3[extra])\n",
+            "  Downloading AutoROM.accept-rom-license-0.6.1.tar.gz (434 kB)\n",
+            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m434.7/434.7 kB\u001b[0m \u001b[31m8.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25h  Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n",
+            "  Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n",
+            "  Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
+            "Requirement already satisfied: typing-extensions>=4.3.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium<0.30,>=0.28.1->stable-baselines3[extra]) (4.12.2)\n",
+            "Collecting farama-notifications>=0.0.1 (from gymnasium<0.30,>=0.28.1->stable-baselines3[extra])\n",
+            "  Using cached Farama_Notifications-0.0.4-py3-none-any.whl.metadata (558 bytes)\n",
+            "Collecting ale-py~=0.8.1 (from shimmy[atari]~=1.3.0; extra == \"extra\"->stable-baselines3[extra])\n",
+            "  Downloading ale_py-0.8.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (8.1 kB)\n",
+            "Requirement already satisfied: absl-py>=0.4 in /usr/local/lib/python3.10/dist-packages (from tensorboard>=2.9.1->stable-baselines3[extra]) (1.4.0)\n",
+            "Requirement already satisfied: grpcio>=1.48.2 in /usr/local/lib/python3.10/dist-packages (from tensorboard>=2.9.1->stable-baselines3[extra]) (1.64.1)\n",
+            "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.10/dist-packages (from tensorboard>=2.9.1->stable-baselines3[extra]) (3.7)\n",
+            "Requirement already satisfied: protobuf!=4.24.0,<5.0.0,>=3.19.6 in /usr/local/lib/python3.10/dist-packages (from tensorboard>=2.9.1->stable-baselines3[extra]) (3.20.3)\n",
+            "Requirement already satisfied: setuptools>=41.0.0 in /usr/local/lib/python3.10/dist-packages (from tensorboard>=2.9.1->stable-baselines3[extra]) (75.1.0)\n",
+            "Requirement already satisfied: six>1.9 in /usr/local/lib/python3.10/dist-packages (from tensorboard>=2.9.1->stable-baselines3[extra]) (1.16.0)\n",
+            "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /usr/local/lib/python3.10/dist-packages (from tensorboard>=2.9.1->stable-baselines3[extra]) (0.7.2)\n",
+            "Requirement already satisfied: werkzeug>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from tensorboard>=2.9.1->stable-baselines3[extra]) (3.0.4)\n",
+            "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch>=1.13->stable-baselines3[extra]) (3.16.1)\n",
+            "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch>=1.13->stable-baselines3[extra]) (3.4.2)\n",
+            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch>=1.13->stable-baselines3[extra]) (3.1.4)\n",
+            "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch>=1.13->stable-baselines3[extra]) (2024.6.1)\n",
+            "Requirement already satisfied: sympy==1.13.1 in /usr/local/lib/python3.10/dist-packages (from torch>=1.13->stable-baselines3[extra]) (1.13.1)\n",
+            "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy==1.13.1->torch>=1.13->stable-baselines3[extra]) (1.3.0)\n",
+            "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->stable-baselines3[extra]) (1.3.0)\n",
+            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib->stable-baselines3[extra]) (0.12.1)\n",
+            "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->stable-baselines3[extra]) (4.54.1)\n",
+            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->stable-baselines3[extra]) (1.4.7)\n",
+            "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->stable-baselines3[extra]) (24.1)\n",
+            "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->stable-baselines3[extra]) (3.2.0)\n",
+            "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib->stable-baselines3[extra]) (2.8.2)\n",
+            "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas->stable-baselines3[extra]) (2024.2)\n",
+            "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.10/dist-packages (from pandas->stable-baselines3[extra]) (2024.2)\n",
+            "Requirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.10/dist-packages (from rich->stable-baselines3[extra]) (3.0.0)\n",
+            "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.10/dist-packages (from rich->stable-baselines3[extra]) (2.18.0)\n",
+            "Requirement already satisfied: importlib-resources in /usr/local/lib/python3.10/dist-packages (from ale-py~=0.8.1->shimmy[atari]~=1.3.0; extra == \"extra\"->stable-baselines3[extra]) (6.4.5)\n",
+            "Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.10/dist-packages (from markdown-it-py>=2.2.0->rich->stable-baselines3[extra]) (0.1.2)\n",
+            "Requirement already satisfied: MarkupSafe>=2.1.1 in /usr/local/lib/python3.10/dist-packages (from werkzeug>=1.0.1->tensorboard>=2.9.1->stable-baselines3[extra]) (3.0.2)\n",
+            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->autorom~=0.6.1->autorom[accept-rom-license]~=0.6.1; extra == \"extra\"->stable-baselines3[extra]) (3.4.0)\n",
+            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->autorom~=0.6.1->autorom[accept-rom-license]~=0.6.1; extra == \"extra\"->stable-baselines3[extra]) (3.10)\n",
+            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->autorom~=0.6.1->autorom[accept-rom-license]~=0.6.1; extra == \"extra\"->stable-baselines3[extra]) (2.2.3)\n",
+            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->autorom~=0.6.1->autorom[accept-rom-license]~=0.6.1; extra == \"extra\"->stable-baselines3[extra]) (2024.8.30)\n",
+            "Downloading AutoROM-0.6.1-py3-none-any.whl (9.4 kB)\n",
+            "Downloading gymnasium-0.29.1-py3-none-any.whl (953 kB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m953.9/953.9 kB\u001b[0m \u001b[31m28.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading Shimmy-1.3.0-py3-none-any.whl (37 kB)\n",
+            "Downloading stable_baselines3-2.3.2-py3-none-any.whl (182 kB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m182.3/182.3 kB\u001b[0m \u001b[31m13.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading ale_py-0.8.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.7 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.7/1.7 MB\u001b[0m \u001b[31m50.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hUsing cached Farama_Notifications-0.0.4-py3-none-any.whl (2.5 kB)\n",
+            "Building wheels for collected packages: AutoROM.accept-rom-license\n",
+            "  Building wheel for AutoROM.accept-rom-license (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
+            "  Created wheel for AutoROM.accept-rom-license: filename=AutoROM.accept_rom_license-0.6.1-py3-none-any.whl size=446660 sha256=663d6689e3906f5403b7df59abdc9bf6d2ad16ad590ad4f03726d9fc8d3c7593\n",
+            "  Stored in directory: /root/.cache/pip/wheels/6b/1b/ef/a43ff1a2f1736d5711faa1ba4c1f61be1131b8899e6a057811\n",
+            "Successfully built AutoROM.accept-rom-license\n",
+            "Installing collected packages: farama-notifications, gymnasium, ale-py, shimmy, AutoROM.accept-rom-license, autorom, stable-baselines3\n",
+            "Successfully installed AutoROM.accept-rom-license-0.6.1 ale-py-0.8.1 autorom-0.6.1 farama-notifications-0.0.4 gymnasium-0.29.1 shimmy-1.3.0 stable-baselines3-2.3.2\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/usr/local/lib/python3.10/dist-packages/tensorflow/lite/python/util.py:55: DeprecationWarning: jax.xla_computation is deprecated. Please use the AOT APIs; see https://jax.readthedocs.io/en/latest/aot.html. For example, replace xla_computation(f)(*xs) with jit(f).lower(*xs).compiler_ir('hlo'). See CHANGELOG.md for 0.4.30 for more examples.\n",
+            "  from jax import xla_computation as _xla_computation\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Using cpu device\n",
+            "Wrapping the env with a `Monitor` wrapper\n",
+            "Wrapping the env in a DummyVecEnv.\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/usr/local/lib/python3.10/dist-packages/stable_baselines3/common/vec_env/patch_gym.py:49: UserWarning: You provided an OpenAI Gym environment. We strongly recommend transitioning to Gymnasium environments. Stable-Baselines3 is automatically wrapping your environments in a compatibility layer, which could potentially cause issues.\n",
+            "  warnings.warn(\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "---------------------------------\n",
+            "| rollout/           |          |\n",
+            "|    ep_len_mean     | 101      |\n",
+            "|    ep_rew_mean     | -107     |\n",
+            "| time/              |          |\n",
+            "|    fps             | 756      |\n",
+            "|    iterations      | 1        |\n",
+            "|    time_elapsed    | 2        |\n",
+            "|    total_timesteps | 2048     |\n",
+            "---------------------------------\n",
+            "----------------------------------------\n",
+            "| rollout/                |            |\n",
+            "|    ep_len_mean          | 58.6       |\n",
+            "|    ep_rew_mean          | -63.8      |\n",
+            "| time/                   |            |\n",
+            "|    fps                  | 728        |\n",
+            "|    iterations           | 2          |\n",
+            "|    time_elapsed         | 5          |\n",
+            "|    total_timesteps      | 4096       |\n",
+            "| train/                  |            |\n",
+            "|    approx_kl            | 0.01260215 |\n",
+            "|    clip_fraction        | 0.109      |\n",
+            "|    clip_range           | 0.2        |\n",
+            "|    entropy_loss         | -2.07      |\n",
+            "|    explained_variance   | -0.0333    |\n",
+            "|    learning_rate        | 0.0003     |\n",
+            "|    loss                 | 13.1       |\n",
+            "|    n_updates            | 10         |\n",
+            "|    policy_gradient_loss | -0.0109    |\n",
+            "|    value_loss           | 95.8       |\n",
+            "----------------------------------------\n",
+            "-----------------------------------------\n",
+            "| rollout/                |             |\n",
+            "|    ep_len_mean          | 28          |\n",
+            "|    ep_rew_mean          | -32.4       |\n",
+            "| time/                   |             |\n",
+            "|    fps                  | 655         |\n",
+            "|    iterations           | 3           |\n",
+            "|    time_elapsed         | 9           |\n",
+            "|    total_timesteps      | 6144        |\n",
+            "| train/                  |             |\n",
+            "|    approx_kl            | 0.011939146 |\n",
+            "|    clip_fraction        | 0.157       |\n",
+            "|    clip_range           | 0.2         |\n",
+            "|    entropy_loss         | -2.04       |\n",
+            "|    explained_variance   | -0.0245     |\n",
+            "|    learning_rate        | 0.0003      |\n",
+            "|    loss                 | 25.8        |\n",
+            "|    n_updates            | 20          |\n",
+            "|    policy_gradient_loss | -0.0172     |\n",
+            "|    value_loss           | 90.1        |\n",
+            "-----------------------------------------\n",
+            "------------------------------------------\n",
+            "| rollout/                |              |\n",
+            "|    ep_len_mean          | 14.9         |\n",
+            "|    ep_rew_mean          | -20.3        |\n",
+            "| time/                   |              |\n",
+            "|    fps                  | 620          |\n",
+            "|    iterations           | 4            |\n",
+            "|    time_elapsed         | 13           |\n",
+            "|    total_timesteps      | 8192         |\n",
+            "| train/                  |              |\n",
+            "|    approx_kl            | 0.0099224895 |\n",
+            "|    clip_fraction        | 0.203        |\n",
+            "|    clip_range           | 0.2          |\n",
+            "|    entropy_loss         | -2           |\n",
+            "|    explained_variance   | -0.003       |\n",
+            "|    learning_rate        | 0.0003       |\n",
+            "|    loss                 | 40.7         |\n",
+            "|    n_updates            | 30           |\n",
+            "|    policy_gradient_loss | -0.0139      |\n",
+            "|    value_loss           | 103          |\n",
+            "------------------------------------------\n",
+            "-----------------------------------------\n",
+            "| rollout/                |             |\n",
+            "|    ep_len_mean          | 10.3        |\n",
+            "|    ep_rew_mean          | -16.5       |\n",
+            "| time/                   |             |\n",
+            "|    fps                  | 601         |\n",
+            "|    iterations           | 5           |\n",
+            "|    time_elapsed         | 17          |\n",
+            "|    total_timesteps      | 10240       |\n",
+            "| train/                  |             |\n",
+            "|    approx_kl            | 0.014140065 |\n",
+            "|    clip_fraction        | 0.183       |\n",
+            "|    clip_range           | 0.2         |\n",
+            "|    entropy_loss         | -1.96       |\n",
+            "|    explained_variance   | -0.000966   |\n",
+            "|    learning_rate        | 0.0003      |\n",
+            "|    loss                 | 73.6        |\n",
+            "|    n_updates            | 40          |\n",
+            "|    policy_gradient_loss | -0.019      |\n",
+            "|    value_loss           | 114         |\n",
+            "-----------------------------------------\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<stable_baselines3.ppo.ppo.PPO at 0x7da1353ab040>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 6
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Part 5: Using A* Pathfinding and Testing the Model**\n",
+        "\n",
+        "In this part, we apply the A* algorithm to find an optimal path from the start to the target. We also test the trained model by running a few steps and observing its behavior in the environment"
+      ],
+      "metadata": {
+        "id": "fSLp-6PM3cdE"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Test A* pathfinding from start to goal\n",
+        "obstacles = [(6, 6), (7, 7)]\n",
+        "start, goal = (5, 5), (8, 8)\n",
+        "path = a_star(start, goal, obstacles, grid_width=10, grid_height=10)\n",
+        "print(\"Optimal path found by A*:\", path)\n",
+        "\n",
+        "# Test the trained agent\n",
+        "obs = env.reset()\n",
+        "for _ in range(20):\n",
+        "    action, _states = model.predict(obs)\n",
+        "    obs, rewards, done, info = env.step(action)\n",
+        "    env.render()\n",
+        "    if done:\n",
+        "        break\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "AAWY4Ejn3Yjw",
+        "outputId": "4feb2cd3-152a-42a0-88f1-b5ebefaf68b9"
+      },
+      "execution_count": 7,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Optimal path found by A*: [(5, 6), (5, 7), (6, 7), (6, 8), (7, 8), (8, 8)]\n",
+            "Drone Position: [6 6], Target: [8 8], Obstacles: [array([6, 6]), array([7, 7])]\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Visualization 1: Environment Setup with Obstacles and Target**\n",
+        "\n",
+        "This code will set up a grid environment, place the drone, target, and obstacles on it, and display the current state of the environment."
+      ],
+      "metadata": {
+        "id": "NZmG9rDZ4THp"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "def visualize_environment(drone_pos, target_pos, obstacles):\n",
+        "    # Define the grid size\n",
+        "    grid_size = (10, 10)\n",
+        "\n",
+        "    # Create a blank grid\n",
+        "    env_grid = np.zeros(grid_size)\n",
+        "\n",
+        "    # Mark obstacles\n",
+        "    for obs in obstacles:\n",
+        "        env_grid[obs[0], obs[1]] = -1  # Obstacles marked as -1\n",
+        "\n",
+        "    # Mark target position\n",
+        "    env_grid[target_pos[0], target_pos[1]] = 2  # Target marked as 2\n",
+        "\n",
+        "    # Mark drone position\n",
+        "    env_grid[drone_pos[0], drone_pos[1]] = 1  # Drone marked as 1\n",
+        "\n",
+        "    # Plot the grid\n",
+        "    plt.imshow(env_grid, cmap=\"coolwarm\", origin=\"upper\")\n",
+        "    plt.colorbar(label=\"Environment Elements\")\n",
+        "    plt.scatter(drone_pos[1], drone_pos[0], color='blue', label=\"Drone\")\n",
+        "    plt.scatter(target_pos[1], target_pos[0], color='green', label=\"Target\")\n",
+        "    for obs in obstacles:\n",
+        "        plt.scatter(obs[1], obs[0], color='red', label=\"Obstacle\" if obs == obstacles[0] else \"\")\n",
+        "\n",
+        "    plt.legend(loc=\"upper right\")\n",
+        "    plt.title(\"Drone Environment with Obstacles and Target\")\n",
+        "    plt.show()\n",
+        "\n",
+        "# Test Visualization\n",
+        "drone_pos = (5, 5)\n",
+        "target_pos = (8, 8)\n",
+        "obstacles = [(6, 6), (7, 7)]\n",
+        "visualize_environment(drone_pos, target_pos, obstacles)\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 452
+        },
+        "id": "SFZkp-QU3pcR",
+        "outputId": "5db87dd3-1af4-42cc-febf-2380fae14b6e"
+      },
+      "execution_count": 8,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Visualization 2: A* Pathfinding Visualization**\n",
+        "\n",
+        "Once the A* algorithm generates a path, we can overlay this path on the environment setup. The path points are highlighted to show the optimal path from the drone’s start position to the target."
+      ],
+      "metadata": {
+        "id": "ql7ZSfxR4aIV"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def visualize_astar_path(drone_pos, target_pos, obstacles, path):\n",
+        "    # Create a grid for the environment\n",
+        "    grid_size = (10, 10)\n",
+        "    env_grid = np.zeros(grid_size)\n",
+        "\n",
+        "    # Mark obstacles\n",
+        "    for obs in obstacles:\n",
+        "        env_grid[obs[0], obs[1]] = -1  # Obstacles marked as -1\n",
+        "\n",
+        "    # Mark target position\n",
+        "    env_grid[target_pos[0], target_pos[1]] = 2  # Target marked as 2\n",
+        "\n",
+        "    # Mark drone position\n",
+        "    env_grid[drone_pos[0], drone_pos[1]] = 1  # Drone marked as 1\n",
+        "\n",
+        "    # Plot the grid with A* path\n",
+        "    plt.imshow(env_grid, cmap=\"coolwarm\", origin=\"upper\")\n",
+        "    plt.colorbar(label=\"Environment Elements\")\n",
+        "    plt.scatter(drone_pos[1], drone_pos[0], color='blue', label=\"Drone Start\")\n",
+        "    plt.scatter(target_pos[1], target_pos[0], color='green', label=\"Target\")\n",
+        "    for obs in obstacles:\n",
+        "        plt.scatter(obs[1], obs[0], color='red', label=\"Obstacle\" if obs == obstacles[0] else \"\")\n",
+        "\n",
+        "    # Draw the A* path\n",
+        "    if path:\n",
+        "        path_x, path_y = zip(*path)\n",
+        "        plt.plot(path_y, path_x, color=\"yellow\", linewidth=2, marker=\"o\", label=\"A* Path\")\n",
+        "\n",
+        "    plt.legend(loc=\"upper right\")\n",
+        "    plt.title(\"A* Pathfinding for Drone Navigation\")\n",
+        "    plt.show()\n",
+        "\n",
+        "# Test A* Visualization\n",
+        "path = a_star(start=drone_pos, goal=target_pos, obstacles=obstacles, grid_width=10, grid_height=10)\n",
+        "visualize_astar_path(drone_pos, target_pos, obstacles, path)\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 452
+        },
+        "id": "hr1bJdal30ZW",
+        "outputId": "cb6746c5-beed-450a-945b-bf4cf3343b1f"
+      },
+      "execution_count": 9,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Visualization 3. Dynamic Environment Visualization with Drone Movement\n",
+        "If you want to visualize the drone moving step-by-step toward the target, this code will update the grid in real-time with each step taken. This approach is particularly helpful in seeing the drone's decision-making process as it progresses.**"
+      ],
+      "metadata": {
+        "id": "MGYh34-34Hyy"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import time\n",
+        "from IPython.display import clear_output\n",
+        "\n",
+        "def visualize_dynamic_path(drone_pos, target_pos, obstacles, path):\n",
+        "    for step in path:\n",
+        "        clear_output(wait=True)\n",
+        "\n",
+        "        # Create environment grid\n",
+        "        grid_size = (10, 10)\n",
+        "        env_grid = np.zeros(grid_size)\n",
+        "\n",
+        "        # Mark obstacles\n",
+        "        for obs in obstacles:\n",
+        "            env_grid[obs[0], obs[1]] = -1  # Obstacles marked as -1\n",
+        "\n",
+        "        # Mark target\n",
+        "        env_grid[target_pos[0], target_pos[1]] = 2  # Target marked as 2\n",
+        "\n",
+        "        # Mark drone position\n",
+        "        env_grid[step[0], step[1]] = 1  # Drone marked as 1\n",
+        "\n",
+        "        # Plot grid\n",
+        "        plt.imshow(env_grid, cmap=\"coolwarm\", origin=\"upper\")\n",
+        "        plt.colorbar(label=\"Environment Elements\")\n",
+        "        plt.scatter(step[1], step[0], color='blue', label=\"Drone\")\n",
+        "        plt.scatter(target_pos[1], target_pos[0], color='green', label=\"Target\")\n",
+        "        for obs in obstacles:\n",
+        "            plt.scatter(obs[1], obs[0], color='red', label=\"Obstacle\" if obs == obstacles[0] else \"\")\n",
+        "\n",
+        "        plt.legend(loc=\"upper right\")\n",
+        "        plt.title(\"Drone Moving Toward Target\")\n",
+        "        plt.show()\n",
+        "\n",
+        "        time.sleep(0.5)  # Adjust time as needed\n",
+        "\n",
+        "# Execute dynamic visualization\n",
+        "drone_pos = (5, 5)\n",
+        "target_pos = (8, 8)\n",
+        "obstacles = [(6, 6), (7, 7)]\n",
+        "path = a_star(start=drone_pos, goal=target_pos, obstacles=obstacles, grid_width=10, grid_height=10)\n",
+        "visualize_dynamic_path(drone_pos, target_pos, obstacles, path)\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 452
+        },
+        "id": "-wnrFh6u4C7N",
+        "outputId": "7ff0ab6d-edaa-46c6-e7c9-2804df2c540f"
+      },
+      "execution_count": 11,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Visualization 4. Heatmap of Pathfinding Costs (A* Algorithm)**\n",
+        "\n",
+        "The following code displays the pathfinding costs generated by the A* algorithm as a heatmap. This can illustrate which areas are more costly to traverse, showing the effectiveness of the chosen path."
+      ],
+      "metadata": {
+        "id": "33jk_6OR5Pbm"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def visualize_cost_heatmap(start, goal, obstacles, grid_width, grid_height):\n",
+        "    # Initialize cost grid with high values\n",
+        "    cost_grid = np.full((grid_width, grid_height), np.inf)\n",
+        "\n",
+        "    # Use A* to calculate cost to each cell from start\n",
+        "    open_set = [(0, start)]\n",
+        "    g_score = {start: 0}\n",
+        "\n",
+        "    while open_set:\n",
+        "        _, current = heapq.heappop(open_set)\n",
+        "        cost_grid[current[0], current[1]] = g_score[current]\n",
+        "\n",
+        "        # Explore neighbors\n",
+        "        for direction in [(1, 0), (0, 1), (-1, 0), (0, -1)]:\n",
+        "            neighbor = (current[0] + direction[0], current[1] + direction[1])\n",
+        "            if neighbor in obstacles or not (0 <= neighbor[0] < grid_width and 0 <= neighbor[1] < grid_height):\n",
+        "                continue\n",
+        "\n",
+        "            tentative_g_score = g_score[current] + 1\n",
+        "            if tentative_g_score < g_score.get(neighbor, np.inf):\n",
+        "                g_score[neighbor] = tentative_g_score\n",
+        "                heapq.heappush(open_set, (tentative_g_score, neighbor))\n",
+        "\n",
+        "    # Plot cost heatmap\n",
+        "    plt.imshow(cost_grid, cmap=\"hot\", origin=\"upper\")\n",
+        "    plt.colorbar(label=\"Traversal Cost\")\n",
+        "    plt.scatter(start[1], start[0], color='blue', label=\"Start\")\n",
+        "    plt.scatter(goal[1], goal[0], color='green', label=\"Goal\")\n",
+        "    for obs in obstacles:\n",
+        "        plt.scatter(obs[1], obs[0], color='red', label=\"Obstacle\" if obs == obstacles[0] else \"\")\n",
+        "\n",
+        "    plt.legend(loc=\"upper right\")\n",
+        "    plt.title(\"Pathfinding Cost Heatmap\")\n",
+        "    plt.show()\n",
+        "\n",
+        "# Visualize cost heatmap\n",
+        "start = (5, 5)\n",
+        "goal = (8, 8)\n",
+        "obstacles = [(6, 6), (7, 7)]\n",
+        "visualize_cost_heatmap(start, goal, obstacles, grid_width=10, grid_height=10)\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 452
+        },
+        "id": "tYzcqAOY4EuZ",
+        "outputId": "2e5ac3d0-5a8f-4360-a66c-cdea1ab2c6d7"
+      },
+      "execution_count": 13,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Visualization 5. 3D Surface Plot of Pathfinding Costs**\n",
+        "\n",
+        "For a different perspective, a 3D surface plot of traversal costs shows how costs vary across the grid, highlighting areas where pathfinding is more challenging due to obstacles or distance."
+      ],
+      "metadata": {
+        "id": "IHPLqUme5eAJ"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from mpl_toolkits.mplot3d import Axes3D\n",
+        "\n",
+        "def visualize_cost_surface(start, goal, obstacles, grid_width, grid_height):\n",
+        "    # Generate cost grid with A* similar to previous heatmap code\n",
+        "    cost_grid = np.full((grid_width, grid_height), np.inf)\n",
+        "    open_set = [(0, start)]\n",
+        "    g_score = {start: 0}\n",
+        "\n",
+        "    while open_set:\n",
+        "        _, current = heapq.heappop(open_set)\n",
+        "        cost_grid[current[0], current[1]] = g_score[current]\n",
+        "\n",
+        "        for direction in [(1, 0), (0, 1), (-1, 0), (0, -1)]:\n",
+        "            neighbor = (current[0] + direction[0], current[1] + direction[1])\n",
+        "            if neighbor in obstacles or not (0 <= neighbor[0] < grid_width and 0 <= neighbor[1] < grid_height):\n",
+        "                continue\n",
+        "            tentative_g_score = g_score[current] + 1\n",
+        "            if tentative_g_score < g_score.get(neighbor, np.inf):\n",
+        "                g_score[neighbor] = tentative_g_score\n",
+        "                heapq.heappush(open_set, (tentative_g_score, neighbor))\n",
+        "\n",
+        "    # Create 3D surface plot\n",
+        "    x, y = np.meshgrid(range(grid_width), range(grid_height))\n",
+        "    fig = plt.figure(figsize=(10, 7))\n",
+        "    ax = fig.add_subplot(111, projection='3d')\n",
+        "    ax.plot_surface(x, y, cost_grid.T, cmap=\"viridis\", edgecolor=\"none\")\n",
+        "\n",
+        "    # Add start, goal, and obstacles\n",
+        "    ax.scatter(start[1], start[0], g_score[start], color='blue', s=50, label=\"Start\")\n",
+        "    ax.scatter(goal[1], goal[0], g_score.get(goal, np.inf), color='green', s=50, label=\"Goal\")\n",
+        "    for obs in obstacles:\n",
+        "        ax.scatter(obs[1], obs[0], 0, color='red', s=50, label=\"Obstacle\" if obs == obstacles[0] else \"\")\n",
+        "\n",
+        "    ax.set_xlabel('X Coordinate')\n",
+        "    ax.set_ylabel('Y Coordinate')\n",
+        "    ax.set_zlabel('Pathfinding Cost')\n",
+        "    ax.set_title(\"3D Pathfinding Cost Surface\")\n",
+        "    plt.legend()\n",
+        "    plt.show()\n",
+        "\n",
+        "# Test 3D cost surface visualization\n",
+        "start = (5, 5)\n",
+        "goal = (8, 8)\n",
+        "obstacles = [(6, 6), (7, 7)]\n",
+        "visualize_cost_surface(start, goal, obstacles, grid_width=10, grid_height=10)\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 654
+        },
+        "id": "kTl56T9u5VBY",
+        "outputId": "b6978a02-fdd4-488a-c420-7cf0ec27899f"
+      },
+      "execution_count": 14,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/usr/local/lib/python3.10/dist-packages/mpl_toolkits/mplot3d/proj3d.py:180: RuntimeWarning: invalid value encountered in divide\n",
+            "  txs, tys, tzs = vecw[0]/w, vecw[1]/w, vecw[2]/w\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x700 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import networkx as nx\n",
+        "\n",
+        "def visualize_navigation_graph():\n",
+        "    G = nx.DiGraph()\n",
+        "    G.add_nodes_from([1, 2, 3, 4, 5])\n",
+        "    G.add_edge(1, 2, weight=1.5)\n",
+        "    G.add_edge(1, 3, weight=2.0)\n",
+        "    G.add_edge(2, 4, weight=1.2)\n",
+        "    G.add_edge(3, 4, weight=0.9)\n",
+        "    G.add_edge(4, 5, weight=1.8)\n",
+        "    G.add_edge(3, 5, weight=1.5)\n",
+        "\n",
+        "    # Define layout\n",
+        "    pos = nx.spring_layout(G)\n",
+        "    plt.figure(figsize=(8, 6))\n",
+        "    nx.draw(G, pos, with_labels=True, node_size=700, node_color=\"lightblue\", edge_color=\"gray\", arrows=True)\n",
+        "\n",
+        "    # Annotate with edge weights\n",
+        "    edge_labels = nx.get_edge_attributes(G, 'weight')\n",
+        "    nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_size=10)\n",
+        "    plt.title(\"Drone Navigation Graph\")\n",
+        "    plt.show()\n",
+        "\n",
+        "# Test the graph visualization\n",
+        "visualize_navigation_graph()\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 659
+        },
+        "id": "zto0OQMm34ft",
+        "outputId": "4b91410d-428c-429d-a4a7-7119459def9e"
+      },
+      "execution_count": 10,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 800x600 with 1 Axes>"
+            ],
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzMAAAKCCAYAAADlSofSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACJw0lEQVR4nOzdd3hUZd4+8PvMTGbSKyGF9MwQSOhVQJCOAoJILwmJurv2dXfffd19ddXtfXVZXcuuJiShiyCISi+CNKUTSkJIQggJIb3NZMr5/aGZn5GaZJJnyv25Lq5dppxzDxNk7jnn+R5JlmUZREREREREDkYhOgAREREREVF7sMwQEREREZFDYpkhIiIiIiKHxDJDREREREQOiWWGiIiIiIgcEssMERERERE5JJYZIiIiIiJySCwzRERERETkkFhmiIiIiIjIIbHMEBFRm2RkZECSJBQUFAjZf2pqKmJiYoTs297FxMRg+vTpomMQEXUZlhkicjotH7Zbfrm7uyM8PBxTpkzBsmXLUFdXJzpih8TExECSJDz33HM33bdnzx5IkoQPP/xQQDLbKSkpwWuvvYYTJ06IjnKT2tpa/P73v8eQIUPg5+cHjUaD6OhozJ8/H1u2bBEdj4jIpbDMEJHT+s1vfoOsrCy8/fbb1g/+L7zwAvr27YtTp04JTtdx//nPf1BSUtLl+01OTkZTUxOio6M7bR8lJSX49a9/fcsy85///AcXLlzotH3fSV5eHgYOHIhXX30VsbGx+O1vf4u3334bjz32GAoKCjB9+nRkZWUJyUZE5IpUogMQEXWWhx56CEOGDLH+/pe//CV27dqF6dOnY8aMGTh37hw8PDxu+/yGhgZ4eXl1RdQ2S0pKwoULF/CnP/0Jy5Yt69J9K5VKKJXKLt3nd7m5uQnZr8lkwqxZs1BWVoa9e/di1KhRre5/9dVXsW3bNpjN5jtux55/roiIHA2PzBCRSxk/fjx+9atfobCwENnZ2dbbU1NT4e3tjUuXLmHq1Knw8fHB4sWLAXzz4fNnP/sZIiMjodFokJCQgL/97W+QZbnVtiVJwrPPPouNGzeiT58+0Gg0SEpKwueff35TjqtXr+Kxxx5DSEiI9XEffPDBPb+OmJgYpKSk3NPRmcLCQjz99NNISEiAh4cHgoKCMHfu3FZrXr766itIkoTly5ff9PytW7dCkiR88sknAG69ZsZiseC1115DeHg4PD09MW7cOOTk5CAmJgapqanWx1VWVuJ//ud/0LdvX3h7e8PX1xcPPfQQTp48aX3Mnj17MHToUABAWlqa9XTBjIwMALdeM9MZ79H3rVu3DmfOnMGvfvWrm4pMi8mTJ+Ohhx6y/r7lz2rv3r14+umn0b17d0RERAC4t/flu9vYt28ffvSjHyEoKAi+vr5ISUlBVVXVLXPs378fw4YNg7u7O+Li4pCZmXnX10dE5IhYZojI5SQnJwMAtm3b1up2k8mEKVOmoHv37vjb3/6G2bNnQ5ZlzJgxA6+//joefPBB/OMf/0BCQgJ+/vOf46c//elN296/fz+efvppLFiwAH/5y1+g1+sxe/ZsVFRUWB9TVlaG++67Dzt27MCzzz6Lf/7zn9BqtXj88cfxxhtv3PPreOmll2AymfCnP/3pjo87evQovvzySyxYsADLli3Dk08+iZ07d2Ls2LFobGwEAAwZMgRxcXFYu3btTc9fs2YNAgICMGXKlNvu45e//CV+/etfY8iQIfjrX/8KnU6HKVOmoKGhodXj8vPzsXHjRkyfPh3/+Mc/8POf/xynT5/GAw88YC1lvXv3xm9+8xsAwA9/+ENkZWUhKysLY8aMueW+O+M9upXNmzcDAJYsWXLHx93K008/jZycHLzyyiv4xS9+AeDe3pfvevbZZ3Hu3Dm89tprSElJwYoVK/DII4/cVNjy8vIwZ84cTJo0CX//+98REBCA1NRUnD17ts25iYjsnkxE5GTS09NlAPLRo0dv+xg/Pz954MCB1t8vXbpUBiD/4he/aPW4jRs3ygDk3/3ud61unzNnjixJkpyXl2e9DYCsVqtb3Xby5EkZgPyvf/3Letvjjz8uh4WFyTdu3Gi1zQULFsh+fn5yY2PjHV9fdHS0PG3aNFmWZTktLU12d3eXS0pKZFmW5d27d8sA5HXr1lkff6vtHTx4UAYgZ2ZmWm/75S9/Kbu5ucmVlZXW2wwGg+zv7y8/9thj1tta/nwvX74sy7Isl5aWyiqVSn7kkUda7eO1116TAchLly613qbX62Wz2dzqcZcvX5Y1Go38m9/8xnrb0aNHZQByenr6TdmXLl0qR0dHW3/fGe/RrQwcOFD29/e/6fb6+nq5vLzc+qumpsZ6X8uf1f333y+bTKZWz7vX96VlG4MHD5abm5utt//lL3+RAcgff/yx9bbo6GgZgLxv3z7rbdevX5c1Go38s5/97I6vj4jIEfHIDBG5JG9v71tONXvqqada/f7TTz+FUqnE888/3+r2n/3sZ5BlGZ999lmr2ydOnIj4+Hjr7/v16wdfX1/k5+cD+OYowvr16/Hwww9DlmXcuHHD+mvKlCmoqanBsWPH7vl1vPzyy3c9OvPddUFGoxEVFRXQarXw9/dvta/58+fDaDTio48+st62bds2VFdXY/78+bfd/s6dO2EymfD000+3uv1W09Y0Gg0Uim/+6TGbzaioqIC3tzcSEhLa9Lq/y9bv0e3U1tbC29v7pttfeuklBAcHW38tWrTopsf84Ac/uGmd0b2+Ly1++MMftlov9NRTT0GlUuHTTz9t9bjExESMHj3a+vvg4GAkJCTc9fURETkilhkickn19fXw8fFpdZtKpbKuZ2hRWFiI8PDwmx7bu3dv6/3fFRUVddO+AgICrGsbysvLUV1djffee6/VB+Dg4GCkpaUBAK5fv37PryMuLg7Jycl47733cO3atVs+pqmpCa+88op1PUm3bt0QHByM6upq1NTUWB/Xv39/9OrVC2vWrLHetmbNGnTr1g3jx4+/bYaWPwOtVtvq9sDAQAQEBLS6zWKx4PXXX4dOp2uV5dSpU62ytIWt36Pb8fHxQX19/U23P/3009i+fTu2b9+OkJCQWz43Njb2ptvu9X1podPpWv3e29sbYWFhN62xae/rIyJyRJxmRkQup7i4GDU1NTd9+P7uUYP2ut2UL/nbdQ0WiwXAN+suli5desvH9uvXr037fOmll5CVlYU///nPeOSRR266/7nnnkN6ejpeeOEFjBgxAn5+fpAkCQsWLLDmaTF//nz8/ve/x40bN+Dj44NNmzZh4cKFUKls88/FH/7wB/zqV7/CY489ht/+9rcIDAyEQqHACy+8cFOWznK39+h2evXqhRMnTuDq1avo0aOH9faePXuiZ8+eAAB3d/dbPvdWU/Pa8r60RXtfHxGRI2KZISKX03IdkDstaG8RHR2NHTt2oK6urtU3/+fPn7fe3xbBwcHw8fGB2WzGxIkT2/Tc24mPj8eSJUvw7rvvYvjw4Tfd/+GHH2Lp0qX4+9//br1Nr9ejurr6psfOnz8fv/71r7F+/XqEhISgtrYWCxYsuOP+W/4M8vLyWh2BqKiouOlowIcffohx48bh/fffb3V7dXU1unXrZv29JEl33Of392/L9+h2pk+fjtWrV2PFihX43//93w5vry3vCwDk5uZi3Lhx1t/X19fj2rVrmDp1aoezEBE5Kp5mRkQuZdeuXfjtb3+L2NhY6+jlO5k6dSrMZjPefPPNVre//vrrkCSp1Rjee6FUKjF79mysX78eZ86cuen+8vLyNm2vxcsvvwyj0Yi//OUvt9zn97+V/9e//nXL66H07t0bffv2xZo1a7BmzRqEhYXddopYiwkTJkClUuHtt99udfv3/8xul2XdunW4evVqq9tarsNyuw/232Xr9+h25s2bh8TERPz2t7/FoUOHbvmYthz9aMv7AgDvvfcejEaj9fdvv/02TCaTzV4fEZEj4pEZInJan332Gc6fPw+TyYSysjLs2rUL27dvR3R0NDZt2nTbU4K+6+GHH8a4cePw0ksvoaCgAP3798e2bdvw8ccf44UXXmi1kPxe/elPf8Lu3bsxfPhw/OAHP0BiYiIqKytx7Ngx7NixA5WVlW3eZsvRmVtdJ6blqvR+fn5ITEzEwYMHsWPHDgQFBd1yW/Pnz8crr7wCd3d3PP7443c99S4kJAQ//vGP8fe//x0zZszAgw8+iJMnT+Kzzz5Dt27dWh1lmT59On7zm98gLS0NI0eOxOnTp7FixQrExcXd9Hr8/f3xzjvvwMfHB15eXhg+fPgt1550xnt0K25ubtiwYQOmTJmC+++/H48++ihGjx4NLy8vXL16FZs2bUJRURGmTZt2T9tr6/vS3NyMCRMmYN68ebhw4QL+/e9/4/7778eMGTNs8vqIiBwRywwROa1XXnkFAKBWqxEYGIi+ffvijTfeQFpa2k2LxW9HoVBg06ZNeOWVV7BmzRqkp6cjJiYGf/3rX/Gzn/2sXblCQkJw5MgR/OY3v8FHH32Ef//73wgKCkJSUhL+/Oc/t2ubwDdHZ7Kzs2/6Zv+f//wnlEolVqxYAb1ej1GjRmHHjh23Pc1u/vz5ePnll9HY2HjHKWbf9ec//xmenp74z3/+gx07dmDEiBHYtm0b7r///lal8f/+7//Q0NCAlStXYs2aNRg0aBC2bNlivfZKCzc3Nyxfvhy//OUv8eSTT8JkMiE9Pf2WZaYz3qPb6dmzJ06cOIFly5Zhw4YN+Oyzz9Dc3IyQkBAMHz4cr776KqZPn35P22rr+/Lmm29ixYoVeOWVV2A0GrFw4UIsW7asTafkERE5G0nmikAiIuoE1dXVCAgIwO9+9zu89NJLouM4rIyMDKSlpeHo0aMYMmSI6DhERHaFa2aIiKjDmpqabrrtjTfeAACMHTu2a8MQEZHL4GlmRETUYWvWrEFGRgamTp0Kb29v7N+/H6tWrcLkyZMxatQo0fGIiMhJscwQEVGH9evXDyqVCn/5y19QW1trHQrwu9/9TnQ0IiJyYlwzQ0REREREDolrZoiIiIiIyCGxzBARERERkUNimSEiIiIiIofEMkNERERERA6JZYaIiIiIiBwSywwRERERETkklhkiIiIiInJILDNEREREROSQWGaIiIiIiMghscwQEREREZFDYpkhIiIiIiKHxDJDREREREQOiWWGiIiIiIgcEssMERERERE5JJYZIiIiIiJySCwzRERERETkkFhmiIiIiIjIIbHMEBERERGRQ2KZISIiIiIih8QyQ0REREREDollhoiIiIiIHBLLDBEREREROSSWGSIiIiIickgsM0RERERE5JBYZoiIiIiIyCGxzBARERERkUNimSEiIiIiIofEMkNERERERA6JZYaIiIiIiBwSywwRERERETkklhkiIiIiInJILDNEREREROSQWGaIiIiIiMghscwQEREREZFDYpkhIiIiIiKHxDJDREREREQOSSU6gCPRm8yo1htRYzDBaLHAIgMKCXBTKOCnUcHf3Q3uKqXomERERERELoFl5i5q9EbkVzeipF4Pg9kCAJBu8Tj52//VKBUI93ZHnL8n/NzduiwnEREREZGrkWRZlu/+MNciyzJK6g24WFmPKr0REv5/WbkXLY8PdHeDLtAb4d4aSNKtKhAREREREbUXy8z36E1mHC+twbUGQ4e31VJqwrw0GBjqx1PQiIiIiIhsiGXmO4rrmnCstAZmi9ymIzF3IwFQKiQMCvVDhI+HDbdMREREROS6WGa+lVtZj9PldZ2+n37BvtAGenX6foiIiIiInB1HM6PrigwAnCqvRV5lQ5fsi4iIiIjImbl8mSmua+qyItPiVHktiuuaunSfRERERETOxqXLjN5kxrHSGiH7PlZaA73JLGTfRERERETOwGXLjCzLOP7tYn8RzBYZx8tqwCVLRERERETt47JlpqTegGsNBptOLWsLGcC1egNK6js+ApqIiIiIyBWpRAcQJbeyvs3PyTt9Ars3rMWZI1+i/OoV+PgHQNd/MBb9+H8RHhvf5u1J3+bo4ePe5ucSEREREbk6lxzNXKM3YmfhjTY/76/P/wDnjx/FyCnTEZ3QG9U3yvHZinToGxvwx9WfIKpnr3blmRDTDX4at3Y9l4iIiIjIVblkmTleWoOCmsY2n2J2/thRxPfpDze12npbSUE+fjpjAkZMmYYf//XNNmeRAMT4eWJgqF+bn0tERERE5Mpccs1MSb2+XWtleg0a2qrIAEB4TBwitT1RfCm3XVnkb/MQEREREVHbuFyZ0ZvMMJgtNtueLMuorrgBn4DAdm/DYLZwTDMRERERURu5XJmp1httur19mz9CZdk1jJo6o0PbsXUuIiIiIiJn53JlpsZggmSjbRXn5+K/v/k/JAwYjLGPzGv3dqRvcxERERER0b1zuTJjtNjmFLOq8uv4w49S4Onjg//553+gVCrtIhcRERERkatwuevMWGwwu62hrha//+FiNNTW4ncrNiAwJNQuchERERERuRKXKzOKDp5j1mzQ449PLUVJQT5e/WANIrU97SIXEREREZGrcbky46Zo/5l1ZrMZ//jJk7h44mu8+FY6EgYOsYtcRERERESuyOXKjJ9G1a5rzADA8j//Gkd3bcOQcZNQX1ONvZvWt7r/gRmz27Vd+dtcRERERER071zuE7S/u1u7n1tw7iwA4Kvd2/HV7u033d/eMtPRXERERERErkiSZdnllp5vySuz6YUzO0qjVGCaNkR0DCIiIiIih+KSCzXCvd1tdq2ZjpLwTR4iIiIiImoblywzcf6e7V43Y2sygLgAT9ExiIiIiIgcjkuWGT93NwTawRoVCUCguxv8NOKzEBERERE5GpcsMwCgC/QWHQGyneQgIiIiInJELltmwr01CPPSCFs7IwEI89Yg3FsjKAERERERkWNz2TIjSRIGhvpBqRBTZ5QKCQND/CBJ9jKKgIiIiIjIsbhsmQEAd5USg0L9hOx7UIgf3FVKIfsmIiIiInIGLl1mACDCxwP9gn27dJ8lx77E0Z2fw2Kxn2vdEBERERE5GpcvMwCgDfTqskLTr7svxvZNwJkzZ7Bu3TqYTKYu2S8RERERkbORZFm2l0uuCFdc14RjpTUwW2SbXodGwjdrZAaF+iHCxwMAcPHiRaxbtw5RUVGYP38+1Gq1DfdIREREROT8WGa+R28y43hpDa41GCABHSo1Lc8P89Zg4C3WyBQUFGDVqlUICQnBokWL4O7u3oG9ERERERG5FpaZW5BlGSX1BuRW1qNSb2xzqWl5fKC7G3SB3gj31tx2allxcTFWrFgBf39/LFmyBF5eXjZ4BUREREREzo9l5i5q9EbkVzeipF4Pg/mbBfu3qiUtf4hK2QxfyYxB0eHwc3e7p32UlZUhKysLHh4eSE5Ohq9v1w4kICIiIiJyRCwzbaA3mVGtN6LGYILRYoFFBhQS4KZQwE+jgr+7G17/619gNBrxxBNPIDw8/J63XVFRgczMTCgUCqSkpCAgIKATXwkRERERkeNjmbEhk8mE3//+9wAAd3d3PPHEEwgKCrrn59fU1CAzMxPNzc1ISUlBcHBwZ0UlIiIiInJ4HM1sQ9evX7f+f4PBgOXLl6O2tvaen+/n54e0tDR4enoiPT0dJSUlnRGTiIiIiMgpsMzYUGlpqfX/y7KM+vp6ZGZmoqmp6Z634e3tjdTUVAQGBiIzMxOFhYWdEZWIiIiIyOGxzNhQWVkZFIr//0cqyzIqKirwySeftGk7LYMAwsLCkJ2djby8PFtHJSIiIiJyeCwzNlRSUgKLxWIdw6xUKtGzZ08MGjSozdvSaDRYtGgRYmNjsWrVKpw7d87WcYmIiIiIHBrLjA25ubkhICAAQ4cOhVKpxJgxY7Bw4ULEx8e3e3vz589H7969sW7dOpw8edLGiYmIiIiIHJdKdABnkpKSYv3/1dXVyM/Px5gxYzq0TaVSiUcffRRqtRobN26EwWDAsGHDOhqViIiIiMjh8chMJ9HpdCgqKoJer+/wthQKBR5++GHcd999+Oyzz/DFF1/YICERERERkWPjkZlOotVqIcsy8vPzkZiY2OHtSZKEyZMnQ6PRYNeuXTAYDJgwYYJ1fQ4RERERkathmekk/v7+CA4ORm5urk3KDPBNoRk7diw0Gg22bdsGg8GAqVOnstAQERERkUtimelEWq0Wp0+fhizLNi0cI0aMgFqtxieffILm5mbMnDmz1UhoIiIiIiJXwE/AnUin06G+vr7VxTRtZfDgwZg9ezbOnDmDDz/8ECaTyeb7ICIiIiKyZywznSgqKgpqtRq5ubmdsv0+ffpg/vz5uHjxIlavXg2j0dgp+yEiIiIiskcsM51IqVQiLi4OeXl5nbaPnj17YvHixSgqKkJ2drZNpqcRERERETkClplOptPpUFxcjKampk7bR2xsLFJSUnD9+nVkZmaisbGx0/ZFRERERGQvWGY6WcuI5kuXLnXqfiIiIrB06VLU1tYiIyMDdXV1nbo/IiIiIiLRWGY6ma+vL0JCQjr1VLMWoaGhSE1NhcFgQHp6Oqqqqjp9n0REREREorDMdAGtVovc3FzIstzp++rWrRvS0tIgSRLS09NRXl7e6fskIiIiIhKBZaYL6HQ6NDY2oqSkpEv25+/vj7S0NHh4eCAjIwPXrl3rkv0SEREREXUllpkuEBERAY1G0yWnmrXw9vZGamoq/P39sXz5chQVFXXZvomIiIiIugLLTBdQKpWIj4/vtOvN3I6HhwdSUlIQGhqK7OzsTh9CQERERETUlVhmuohWq8XVq1fR0NDQpfvVaDRYvHgxYmJisGrVKpw7d65L909ERERE1FlYZrqIVqsFACFHR9zc3DB//nwkJCRg3bp1OHXqVJdnICIiIiKyNZaZLuLj44OwsLAuXTfzXUqlErNnz0b//v2xYcMGHD16VEgOIiIiIiJbUYkO4Eq0Wi2++uorWCwWKBRd3yMVCgVmzJgBjUaDTz/9FAaDAffff3+X5yAiIiIisgUemelCOp0OTU1NuHr1qrAMkiRhypQpGDNmDHbu3ImdO3d2yfVviIiIiIhsjUdmulCPHj3g4eGBvLw8REZGCsshSRLGjRsHjUaD7du3w2Aw4KGHHoIkScIyERERERG1FY/MdCGFQiFkRPPtjBw5EtOnT8fRo0exadMmWCwW0ZGIiIiIiO4Zj8x0Ma1WizNnzqC+vh7e3t6i42Dw4MFQq9XYsGEDmpub8eijj0KpVIqORURERER0Vzwy08VaRjSLmmp2K3379sX8+fNx4cIFrF69GkajUXQkIiIiIqK7YpnpYl5eXggPD7erMgMACQkJWLRoEQoLC5GdnQ2DwSA6EhERERHRHbHMCKDT6XDp0iW7W6MSFxeH5ORklJWVITMzE42NjaIjERERERHdFsuMADqdDnq9HsXFxaKj3CQyMhKpqamorq5GRkYG6urqREciIiIiIrollhkBwsPD4enpaTdTzb4vNDQUaWlpMBgMSE9PR3V1tehIREREREQ3YZkRQJIkaLVauy0zANCtWzekpaUBAD744APcuHFDcCIiIiIiotZYZgTRarUoKytDbW2t6Ci35e/vj7S0NLi7uyM9PR3Xrl0THYmIiIiIyIplRpD4+HhIkmR3U82+z8fHB6mpqfD398fy5ctx5coV0ZGIiIiIiACwzAjj6emJHj162H2ZAb7JmpKSgtDQUGRlZSE/P190JCIiIiIilhmRWkY0m81m0VHuSqPRYPHixYiOjsbKlStx/vx50ZGIiIiIyMWxzAik0+nQ3NzsMKduubm5YcGCBUhISMDatWtx6tQp0ZGIiIiIyIWxzAgUGhoKLy8vu55q9n1KpRKzZ89G//79sWHDBnz11VeiIxERERGRi2KZEUiSJOh0OocqMwCgUCgwY8YMDBs2DFu2bMGBAwdERyIiIiIiF6QSHcDVabVanDhxAjU1NfDz8xMd555JkoQHH3wQGo0GO3bsgMFgwLhx4yBJkuhoREREROQieGRGsJYRzY52dAb4ptCMHz8eEydOxBdffIGtW7dClmXRsYiIiIjIRbDMCObu7o7IyEiHGNF8O6NGjcK0adNw+PBhbNq0CRaLRXQkIiIiInIBPM3MDuh0Ouzbtw8mkwkqlWO+JUOGDIFarcbGjRvR3NyMRx99FEqlUnQsIiIiInJiPDJjB7RaLYxGI4qKikRH6ZB+/fph3rx5uHDhAlavXg2j0Sg6EhERERE5MZYZOxASEgIfHx+HXDfzfb169cKiRYtQWFiIFStWwGAwiI5ERERERE6KZcYOSJIErVbr0OtmvisuLg7JyckoLS1FZmYmGhsbRUciIiIiIifEMmMndDodbty4gaqqKtFRbCIyMhJLly5FdXU1li9fjrq6OtGRiIiIiMjJsMzYibi4OCgUCqc41axFWFgYUlNT0dTUhIyMDFRXV4uOREREREROhGXGTmg0GkRFRTnNqWYtgoODkZaWBlmWkZ6ejhs3boiOREREREROgmXGjuh0Oly+fNnppoAFBAQgLS0NGo0G6enpKC0tFR2JiIiIiJwAy4wd0Wq1MJlMKCwsFB3F5nx8fJCamgo/Pz8sX74cV65cER2JiIiIiBwcy4wdCQ4Ohp+fn1Otm/kuT09PpKSkoHv37sjKykJ+fr7oSERERETkwFhm7IizjWi+FXd3dyxZsgRRUVFYuXIlLly4IDoSERERETkolhk7o9PpUFlZiYqKCtFROo2bmxsWLFiAnj17Ys2aNTh9+rToSERERETkgFhm7ExsbCyUSqXTnmrWQqVSYc6cOejXrx8++ugjfP3116IjEREREZGDYZmxM2q1GtHR0U59qlkLhUKBmTNnYujQofjkk09w8OBB0ZGIiIiIyIGoRAegm2m1WuzcuRPNzc1Qq9Wi43QqSZLw0EMPQaPRYNu2bTAYDHjggQcgSZLoaERERERk53hkxg7pdDqYzWYUFBSIjtIlJEnChAkTMGHCBOzduxfbtm2DLMuiYxERERGRneORGTsUFBSEgIAA5ObmomfPnqLjdJn7778fGo0Gn376KQwGA6ZPnw6Fgn2biIiIiG6NZcYOtYxozs3NhSzLLnXK1dChQ6FWq/Hxxx+jubkZs2bNglKpFB2LiIiIiOwQv/a2UzqdDtXV1bhx44boKF2uf//+mDt3Ls6fP481a9bAaDSKjkREREREdohlxk7FxMRApVK5xFSzW+nduzcWLlyIy5cvY+XKlTAYDKIjEREREZGdYZmxU25uboiJiXH6683cSXx8PJKTk3Ht2jVkZWWhqalJdCQiIiIisiMsM3ZMq9WisLDQpY9KREVFYenSpaisrERGRgbq6+tFRyIiIiIiO8EyY8d0Oh0sFgsuX74sOopQYWFhSEtLQ1NTE9LT01FTUyM6EhERERHZAZYZOxYYGIigoCCXPtWsRXBwMNLS0mCxWPDBBx+goqJCdCQiIiIiEoxlxs5ptVrk5eXxIpIAAgICkJaWBrVajfT0dJSVlYmOREREREQCsczYOZ1Oh9raWpSXl4uOYhd8fX2RmpoKHx8fZGRkoLi4WHQkIiIiIhKEZcbORUdHw83NjaeafYeXlxeWLl2K4OBgZGZmuvyaIiIiIiJXxTJj51QqFWJjY1lmvsfd3R1LlixBVFQUVqxYgYsXL4qORERERERdjGXGAWi1Wly5cgV6vV50FLuiVquxYMEC6HQ6rFmzBmfOnBEdiYiIiIi6EMuMA2gZ0Zyfny86it1RqVSYO3cu+vTpg/Xr1+PYsWOiIxERERFRF2GZcQD+/v7o1q0bTzW7DYVCgUceeQRDhgzB5s2bcejQIdGRiIiIiKgLqEQHoHuj0+lw+vRpyLIMSZJEx7E7kiRh6tSp0Gg02Lp1KwwGA8aMGcM/KyIiIiInxiMzDkKn06G+vp7XVrkDSZIwceJEjB8/Hnv27MH27dt5fR4iIiIiJ8YjMw4iKioKarUaubm5CA0NFR3Hro0ePRoajQafffYZDAYDpk2bBoWCvZ2IiIjI2fATnoNQKpWIi4vjupl7NGzYMMycORPHjx/Hhg0bYDabRUciIiIiIhtjmXEgWq0WxcXFaGpqEh3FIQwYMABz5sxBTk4O1q5dC5PJJDoSEREREdkQy4wD0el0kGUZly5dEh3FYSQmJmLhwoXIz8/HypUr0dzcLDoSEREREdkIy4wD8fX1Rffu3ZGXlyc6ikPRarVYsmQJSkpKkJWVxSNbRERERE6CZcbB6HQ65OXlcUpXG0VHRyMlJQUVFRVYvnw56uvrRUciIiIiog5imXEwWq0WDQ0NuHbtmugoDic8PBypqaloaGhARkYGampqREciIiIiog5gmXEwkZGR0Gg0nGrWTt27d0daWhrMZjPS09NRUVEhOhIRERERtRPLjINRKpWIj4/nupkOCAwMRFpaGtzc3JCens4LkRIRERE5KJYZB9QyormxsVF0FIfl6+uL1NRU+Pj4ICMjA1evXhUdiYiIiIjaiGXGAWm1WgDg0ZkO8vLywtKlSxEcHIzMzEwUFBSIjkREREREbcAy44B8fHwQGhrKMmMD7u7uWLJkCSIiIrBixQquRSIiIiJyICwzDqplRLPFYhEdxeGp1WosXLgQ8fHxWL16Nc6ePSs6EhERERHdA5YZB6XVatHU1ISSkhLRUZyCSqXC3LlzkZSUhPXr1+P48eOiIxERERHRXahEB6D2iYiIgLu7O3JzcxERESE6jlNQKpWYNWsW1Go1Nm3aBIPBgPvuu090LCIiIiK6DR6ZcVAKhQJarZbrZmxMkiRMmzYNI0eOxNatW7Fv3z7Isiw6FhERERHdAsuMA9NqtSgpKUF9fb3oKE5FkiRMnDgR48ePx+7du7F9+3YWGiIiIiI7xDLjwDiiufNIkoTRo0fjwQcfxMGDB7FlyxYOWyAiIiKyMywzDszLywvh4eEsM51o+PDhmDlzJo4dO4aNGzfCbDaLjkRERERE32KZcXBarRaXLl3iUYNONGDAAMyZMwdnz57lGhoiIiIiO8JpZg5Op9Nh3759KC4uRlRUlOg4TisxMdF6sVJZliFJ0h0fX1hYCC8vL3Tr1q2LEhIRERG5Hh6ZcXDh4eHw9PTkleu7QGRkJFQqFRSKO/+1uXLlCt58800sXLgQhw4d6qJ0RERERK6HZcbBKRQKxMfHc91MF7nbERngm9Izbdo0JCYmYuTIkfj666+7IBkRERGR62GZcQI6nQ6lpaWoq6sTHcXlGY1GAMDYsWNx5coVBAUF4fr161xnQ0RERNQJWGacQHx8PACOaBbNYrHAzc0NAPD4449j586dSE9Px4QJE+7piA4RERERtQ3LjBPw9PREREQE180IZLFYrGtpfvzjH2P16tX4z3/+g8mTJ0OtVgtOR0REROScWGachFarRX5+Pq+D0sWMRiOMRqO1yLz88st4++238e9//xszZsxgkSEiIiLqRCwzTkKn08FgMODKlSuio7gMWZbx3//+F08++SQA4M9//jP++Mc/4p///Cfmzp0Ld3f32z6PiIiIiDqO15lxEmFhYfDy8kJubi5iYmJEx3EJkiRh4sSJeP7553H48GFcvHgRf/vb35CSkgJPT887Ps9oNKKiogKhoaFdmJiIiIjIufDIjJOQJAlarZZDALqYTqdDUVERZFlG9+7d8cgjj8DLy+uOz5FlGX/729/w85//HK+99lrXBCUiIiJyQiwzTkSn0+H69euoqakRHcWlhIWF4csvv4RCocBTTz3V6s//VqeUSZKEGTNmYNSoUVi/fj1mzZrVlXGJiIiInAbLjBOJi4uDJEk8OiOAn58fcnNz0bNnT5hMJly+fBnl5eW3HcmclJSEJ598Etu3b8fly5fxyiuvdHFiIiIiIsfHMuNEPDw8EBkZyRHNgmg0GixbtgwKhQI/+tGP8OMf/xi1tbW3XfBvMBgQGhqKGTNm4MKFC7BYLF2cmIiIiMixcQCAk9Fqtdi/fz9MJhNUKr69IgQEBKBPnz4ICQmBr6/vbR+n0WgAAEeOHAEA63hnIiIiIro3/LTrZHQ6HXbt2oWioiLExcWJjuOy/vGPf1j//8WLF9HY2AhZlqFUKlFeXo6mpiZUV1cjIyMDpaWlePHFFwWmJSIiInJMLDNOJiQkBD4+PsjNzWWZsQM7d+7EvHnzUFVVhb59+0Kv16O6uhp+fn4IDw+Ht7c3/vGPf2DkyJGioxIRERE5HEnmFfyczqZNm3DlyhU888wzoqMQgF/96lf4/e9/j127dmHs2LGoqqqCp6en9TSzFrIs33ZgABERERHdjEdmnJBOp8Px48dRVVWFgIAA0XFc3m9/+1vU1dXhkUcewdatWzF8+PBWQwFaSgyLDBEREVHbcMWxE4qLi4NCoeCIZjvyxhtv4LnnnsPIkSOxd+/eVsWFJYaIiIiofVhmnJBGo0FUVBRHNNuZ3/72t/jrX/+Kd999F/X19aLjEBERETk8nmbmpLRaLfbs2cMRzXbmpz/9KSoqKuDt7X3TfVwzQ0RERNQ2PDLjpHQ6HUwmEwoKCkRHoe8JCgq66TZZlnHu3DlUVVUJSERERETkmFhmnFRwcDB8fX15qpmDMJlM2LVrFz744AOUl5eLjkNERETkEFhmnJQkSdDpdBwC4CDc3NyQmpoKLy8vpKeno6SkRHQkIiIiIrvHMuPEdDodKisrUVFRIToK3QNvb28sXboUgYGByMzMRGFhoehIRERERHaNZcaJxcbGQqlU8uiMA/Hw8EBycjLCwsKQnZ3N946IiIjoDlhmnJharUZ0dDQ/EDsYjUaDxYsXIy4uDqtWrcK5c+dERyIiIiKySywzTk6r1eLy5cswGo2io1AbqFQqzJs3D4mJiVi3bh1OnjwpOhIRERGR3WGZcXI6nQ5msxmXL18WHYXaSKlUYtasWRgwYAA2btyII0eOiI5EREREZFd4NUUnFxQUBH9/f+Tl5aFnz56i41AbKRQKPPzww9BoNPjss89gMBgwevRo0bGIiIiI7ALLjJNrGdGcm5vLK8w7KEmSMHnyZLi7u2PXrl0wGAyYMGEC30siIiJyeTzNzAVotVpUV1dzRLMDkyQJDzzwACZPnowDBw7g008/hSzLomMRERERCcUjMy6gZURzbm4uunXrJjoOdcCIESOg0WiwefNmNDc3Y+bMmVAo+J0EERERuSZ+CnIBbm5uiI2N5YhmJzFo0CDMnj0bZ86cwbp162AymURHIiIiIhKCZcZFaLVaFBQUoLm5WXQUsoE+ffpg/vz5yM3NxerVq/m+EhERkUtimXEROp0OFosF+fn5oqOQjfTs2ROLFy/GlStXkJ2dDb1eLzoSERERUZdimXERgYGBCAwM5KlmTiY2NhbJyckoLy9HZmYmGhoaREciIiIi6jIsMy5Eq9VaRzST84iIiEBqaipqa2uRkZGB2tpa0ZGIiIiIugTLjAvR6XSora1FeXm56ChkYyEhIUhLS0NzczPS09NRVVUlOhIRERFRp2OZcSExMTFQqVTIzc0VHYU6QVBQEB577DEoFAqkp6eztBIREZHTY5lxISqViiOanZyfnx/S0tLg4eGBjIwMXLt2TXQkIiIiok7DMuNidDodioqKYDAYREehTuLt7Y3U1FQEBARg+fLlKCoqEh2JiIiIqFOwzLgYrVbLEc0uwMPDA8nJyQgLC0N2djYuXbokOhIRERGRzbHMuJiAgAB069aN62ZcgEajwaJFixATE4NVq1bh3LlzoiMRERER2RTLjAvSarXIy8vjiGYX4Obmhvnz56NXr15Yt24dTp06JToSERERkc2wzLggnU6Huro6lJWViY5CXUCpVOLRRx/FgAEDsGHDBhw9elR0JCIiIiKbUIkOQF0vKioKarUaubm5CA0NFR2HuoBCocDDDz8MtVqNTz/9FAaDAffff7/oWEREREQdwiMzLogjml2TJEmYMmUKHnjgAezcuRM7d+7kqYZERETk0FhmXJROp8OVK1fQ1NQkOgp1IUmSMHbsWEyaNAn79+/HZ599xkJDREREDotlxkVptVrIsswRzS5q5MiRmD59Oo4ePYqPP/4YFotFdCQiIiKiNmOZcVF+fn7o3r07RzS7sMGDB+PRRx/F6dOn8eGHH8JkMomORERERNQmLDMujCOaqW/fvpg3bx4uXryI1atXw2g0io5EREREdM9YZlyYTqdDQ0MDrl27JjoKCZSQkIDFixejqKgI2dnZ0Ov1oiMRERER3ROWGRcWGRkJjUbDU80IsbGxSElJwfXr15GZmYnGxkbRkYiIiIjuimXGhSmVSsTFxXFEMwEAIiIisHTpUtTW1iIjIwN1dXWiIxERERHdEcuMi9PpdCguLuY38QQACA0NRWpqKgwGA9LT01FVVSU6EhEREdFtscy4OK1WCwC4dOmS4CRkL7p164a0tDQAQHp6Om7cuCE4EREREdGtscy4OB8fH4SGhnLdDLXi7++PtLQ0eHh4ID09nUMiiIiIyC6xzBC0Wi0uXbrECydSKz4+Pli6dCn8/f2xfPlyXLlyRXQkIiIiolZYZgg6nQ6NjY0oKSkRHYXsjKenJ1JSUhAaGoqsrCzk5+eLjkRERERkxTJDiIiIgLu7O081o1vSaDRYvHgxoqOjsXLlSpw/f150JCIiIiIALDMEQKFQID4+niOa6bbc3NywYMECJCQkYO3atTh16pToSEREREQsM/QNnU6HkpIS1NfXi45CdkqpVGL27Nno378/NmzYgK+++kp0JCIiInJxLDMEAIiPjwfAEc10ZwqFAjNmzMCwYcOwZcsWHDhwQHQkIiIicmEq0QHIPnh7eyM8PBx5eXno37+/6DhkxyRJwoMPPgh3d3fs2LEDBoMB48aNgyRJoqMRERGRi2GZISutVosjR47AYrFAoeBBO7o9SZIwbtw4qNVqa6F58MEHWWiIiIioS7HMkFW/fv0QFBQkOgY5kFGjRkGj0WDLli1obm7Gww8/zCJMREREXUaSZVkWHYLsh9lshlKpFB2DHMzp06exYcMG9O7dG48++ih/hoiIiKhLsMwQkU2cP38eH374IWJjYzFv3jy4ubmJjkREREROjmWGiGwmPz8fq1evRnh4OBYuXAiNRiM6EhERETkxlhlqE5PJhPz8fJhMJiQmJoqOQ3boypUrWLFiBYKCgrB48WJ4enqKjkREREROiit1qU2MRiMyMzPx8ssvw2QyiY5DdigyMhKpqamorq5GRkYG6urqREciIiIiJ8UyQzcxmUywWCwAAFmWW/3ew8MDKSkpyMnJwdatW0XGJDsWGhqKtLQ06PV6pKeno7q6WnQkIiIickIsM3ST3/3ud1i3bh2Ab64nolKpoFAoUF9fj7Vr1+LnP/85Ll68iN27dwtOSvasW7dueOyxxwAA6enpuHHjhuBERERE5GxYZugmFy9eREZGBgDgzJkzePnll9GnTx/4+vriySefhNlsxt///nfMmzdPbFCye/7+/khLS4NGo0F6ejpKS0tFRyIiIiInwgEAdJMvv/wS999/PwICAlBdXY2EhASMGzcO48ePR58+fRAWFgZvb29eHJHuWWNjI7Kzs1FVVYVFixYhMjJSdCQiIiJyAiwzdEt+fn6YM2cOnnjiCcTExCAwMJBjdqlDDAYDVq5ciWvXrmHBggWIi4sTHYmIiIgcHL9ap1vq27cvVCoVRowYgbCwMBYZ6jCNRoMlS5YgOjoaK1euxIULF0RHIiIiIgfHMkO39MMf/hBVVVUwm83gwTuyFTc3NyxYsAA9e/bEmjVrcPr0adGRiIiIyIHxNDO6JaPRiPr6egQEBIiOQk7IYrFg8+bNOHHiBKZPn47BgweLjkREREQOiEdm6Jbc3Nywf/9+/PCHP0ReXh4A8AgN2YxCocCMGTMwbNgwfPLJJ/jyyy9FRyIiIiIHxDJDt1VYWIgdO3ZYy4wkSbd8nMFg6MpY5CQkScKDDz6I0aNHY/v27di9ezcLMxEREbUJTzOj26qrq0NzczOCgoJa3W42m9HY2Ijy8nKcOHECu3btwv/+7/8iKipKUFJydAcOHMCOHTswfPhwTJky5bbFmYiIiOi7VKIDkP3y8fEBANTX10Oj0cDNzQ0AkJ+fjzfffBPvv/8+lEol6urq4OXlhT//+c8i45IDGzVqFNRqNT799FM0Nzdj+vTpvI4RERER3RU/LdAdHTx4EK+88or1VDMA8PT0RGlpKRITE1FTU4PMzEx89NFHAlOSMxg6dChmzZqFEydO4KOPPoLZbBYdiYiIiOwcywzdUVVVFfbs2dPqVLMePXrgySefRHV1NQBg7NixKCoqQl1dnaCU5Cz69euHefPm4fz581izZg2MRqPoSERERGTHWGbojkaMGIHz58/DaDRClmXrAm21Wg2LxYKLFy8iIiICXl5eWLFiheC05Ax69eqFhQsXoqCgACtWrOCACSIiIrotlhm6o4CAACQkJGDFihWQJMm6MDsjIwMREREIDg4GALz77rvo27evyKjkROLj47FkyRKUlpYiKysLTU1NoiMRERGRHeI0M7qr999/H++++y7Cw8Mxbtw4XLx4EZs3b8aLL76IZ555RnQ8cmLXrl1DdnY2vL29kZycDG9vb9GRiIiIyI6wzNBdmUwmbNmyBb///e/R3NwMT09PzJ49Gz/96U85Qpc6XXl5ObKysuDm5obk5GT4+/uLjkRERER2gmWG7lljYyOKiooQFxcHtVotOg65kKqqKmRmZsJisSAlJeWmax8RERGRa2KZoXaxWCyt1tAQdbba2lrr+pnk5GSEhISIjkRERESCscwQkcNobGxEdnY2qqqqsHjxYkRERIiORERERAKxzBCRQ9Hr9Vi1ahWuXbuGhQsXIjY2VnQkIiIiEoRlhogcjtFoxJo1a1BQUIB58+ahZ8+eoiMRERGRACwz1GayLHOtDAlnMpnw0Ucf4cKFC5g1axb69OkjOhIRERF1MV40k9pElmVcv34d7MAkmkqlwpw5c9C3b1+sX78ex44dEx2JiIiIuhjLDLXJpUuX8M4776CiokJ0FCIoFArMnDkTQ4cOxebNm3Hw4EHRkYiIiKgLqUQHIMcSFRUFpVKJ3NxcdOvWTXQcIkiShIceeggajQbbtm2DwWDAAw88wFMhiYiIXACPzFCbqNVqxMTEIC8vT3QUIitJkjBhwgRMmDABe/fuxbZt23gqJBERkQtgmaE20+l0KCwsRHNzs+goRK3cf//9mDp1Kg4dOoTNmzfDYrGIjkRERESdiGWG2kyr1cJsNuPy5cuioxDdZOjQoXjkkUdw4sQJfPTRRzCbzaIjERERUSdhmaE2CwoKQmBgIHJzc0VHIbql/v37Y+7cuTh37hzWrl0Lo9EoOhIRERF1ApYZahetVou8vDyuSyC71bt3byxcuBD5+flYuXIlDAaD6EhERERkYywz1C46nQ41NTUoLy8XHYXotrRaLZKTk3Ht2jVkZWWhqalJdCQiIiKyIZYZapfo6GioVCqeakZ2LyoqCkuXLkVlZSWWL1+O+vp60ZGIiIjIRlhmqF3c3NwQGxvLEc3kEMLCwpCWlobGxkakp6ejpqZGdCQiIiKyAZYZajetVouioiKuRSCHEBwcjLS0NFgsFnzwwQeoqKgQHYmIiIg6iGWG2k2n08FisSA/P190FKJ7EhAQgLS0NKjVaqSnp6OsrEx0JCIiIuoAlhlqt4CAAHTr1o3rZsih+Pr6IjU1FT4+PsjIyMDVq1dFRyIiIqJ2YpmhDuGIZnJEXl5eWLp0KYKDg5GZmYmCggLRkYiIiKgdWGaoQ3Q6Herq6ni6Djkcd3d3LFmyBBEREVixYgWPMBIRETkglhnqkKioKLi5uXGqGTkktVqNhQsXQqvVYvXq1Th79qzoSERERNQGLDPUISqVCnFxcfxWmxyWSqXC3Llz0adPH6xfvx7Hjx8XHYmIiIjuEcsMdZhWq8WVK1eg1+tFRyFqF4VCgUceeQSDBw/Gpk2bcOjQIdGRiIiI6B6oRAcgx6fT6SDLMi5duoSkpCTRcYjaRZIkTJ06FRqNBlu3boXBYMCYMWMgSZLoaERE5IT0JjOq9UbUGEwwWiywyIBCAtwUCvhpVPB3d4O7Sik6pt1jmaEO8/PzQ3BwMPLy8lhmyKFJkoSJEydCo9Fg165dMBgMmDRpEgsNERHZRI3eiPzqRpTU62EwWwAAt/oXpmVGrEapQLi3O+L8PeHn7tZlOR0JywzZhE6nw8mTJyHLMj/4kcMbPXo0NBoNPvvsMxgMBkybNg0KBc/KJSKitpNlGSX1BlysrEeV3ggJ/7+s4Hv///sMZgsKahpxuaYRge5u0AV6I9xbw89a38F/nckmdDodGhoaUFpaKjoKkU0MGzYMM2fOxPHjx7FhwwaYzWbRkYiIyMHoTWYculqFwyVVqNIbAdy5vNxKy+Or9EYcLqnCoatV0Jv4b1ILlhmyicjISKjVak41I6cyYMAAzJkzBzk5OVi7di1MJhMAwGKx4OLFi7BYLIITEhGRvSqua8K2y+UobTDYZHstpaa0wYBtl8tRXNdkk+06OpYZsgmlUon4+HiWGXI6iYmJWLhwIfLz87Fy5UoYDAZ88sknWLVqFcc4ExHRLeVW1uNISTVMFrnNR2LuRgZgssg4UlKNvMoGG2/d8UiyLNv6z5hc1LFjx/DJJ5/gf/7nf+Dp6Sk6DpFNFRYWYsWKFVCr1Who+OYfj4iICDz++OP3vA1OriEicn65lfU4XV7XZfvrF+wLbaBXl+3P3nAAANnMd0c09+3bV3QcIpuKjo5G3759cezYMettxcXFqKqqQkBAwG2fx8k1RESuo7iuqUuLDACcKq+Fu5sCET4eXbpfe8HTzMhmfHx8EBISgry8PNFRiGzu0KFDrYoM8M0o51OnTt30WFmWcbVOj92FN7Cz8AYKahqtRQb4prh8/1eLlsk1OwtvYE/hDVyt04MH0ImI7J/eZMax0hoh+z5WWuOyQwFYZsimdDod8vLy+OGLnE5OTg4AtBrRLMsyjh071urnnZNriIhcjyzLOF5aA7NFzOcfs0XG8bIal/z8xTJDNqXT6dDY2IiSkhLRUYhsaunSpUhJScGwYcPg5+dnvb22thYXL14EwMk1RESuqqTegGsNBpsv9r9XMoBr9QaU1Nvm3x9HwjUzZFMRERFwd3dHbm4uevToIToOkc0olUrExsYiNjYWkydPxo0bN3D69GmcOHECQOcu+Pzu5Bp9sMWlF3oSEdmj3Mr6Nj/nzOEv8erSObe874+rN6PngMFt2p70bY4ePu5tzuLIWGbIphQKhXVE89ixY0XHIeoUkiQhODgY48ePx/jx47t0cs2p8loAYKEhIrITNXojKr89rbg9piY/Dm3fAa1uC42OafN2ZACVeiNqDEb4aVxngAzLDNmcVqvFxx9/jIaGBnh58QMXOTdOriEicm351Y2Q0Pb1kS0SBw/HiAen2ySLBCC/qhEDQ/3u+lhnwTUzZHNarRYAONWMnB4n1xARUUm9vsNrZZrq62E2mTqcRf42jyvhkRmyOW9vb4SFhSEvLw/9+/cXHYeoU9jL5Jr7wgMgSbe6cg2RfbBYLDAavzkFR61W3/XntaGhAfn5+aivr4ebmxsiIyMREhLSFVGJ2kxvMrcavd8eb/7fT6BvbIBCqUTvwcOR8vNfQdu3/Z+fDGYL9Cazy1yEmWWGOoVOp8ORI0dgsVhajbIlchYtk2tE+e7kGldb7EmO4+OPP8brr7+O48ePw2KxYOvWrRg5cuRtH19VVYXXXnsNW7ZsQXNzM9zd3dG3b1/86U9/gk6n68LkRN/Yt28fTpw4gZEjR2LAgAFQqVp/dK7uwFoZlZsb7ps8DYMeGA/fgEBcybuITR+8g18tmYXfr/oYcYntvwB5td6IUG/XKDP8lEmdQqvVQq/X4+rVq6KjEHWK9kyuuZUP3/knZvcKxwsPj2vzc1sm1xDZI1mW0dzcjKlTp+LNN9+E0Wi86YPg961duxbvvPMO1qxZg6KiIqxfvx5FRUX4yU9+Yt0mUVeqrKxEVVUVtmzZgjfeeAOHDh2yHmkEgBqDCe09Nt5r0FD8fNl/MGH2QgwdPwWP/vA5/HHNJ4AErPjHH9udWfo2l6vgkRnqFD169ICHhwdyc3MRGRkpOg6RTXV0ck2LitISfPTuMrh7erbr+a46uYYcgyRJmDt3LgDg6tWraG5uhsVy+9NxmpubcfnyZSQkJGDw4G9G0vbt2xdjxozB3r17uyQzOSdZlmGxWG776073NzY2QpIkyLKMhoYGbN26Fbt370bv3r0xffp0GO/wM90eYdGxGDp+Cg5v/wxmsxlKZfuOrtg6lz1jmaFOoVAooNVqkZeXh/Hjx4uOQ2RTHZ1c02L5X36Dnv0Hw2I2o7a6sl3bcMXJNeR4Wj6Qmc23H1qhVqsxdepUrF+/Hu+88w4GDhyIc+fO4ciRI3jxxRcBgOvD7oEsy9YP5x35EG+L++/2mFvd1xmZbK25uRknT55EbGwspLBYm2+/W1g4TMZmGJoa4ent065tCFrOKQTLDHUarVaL06dPo66uDj4+7fvLSGSPbDG55uzRQzi4dQv+9tE2vP+7l9u9nZbJNQPBMkP2q+X0srt9sBw9ejSeffZZ/PznP4eHhweam5sxbtw4PPTQQ7d9znc/vHfVh/D23t/WD/bt3WdXUigUkCQJCoXitr/aer+bm9tdn9/Rfd7rNvbv34+cnBxYLBbrEZrw8HCMHTsWOp0OZ7699pctlV0pglrjDnfP9l/eQuFCvZ9lhjpNfHw8gG9GNA8cOFBwGiLbsMXkGrPZjPd/9zImzlmE6ITeHc7kapNrXN2tPrx35bft378/Pj4ekZGRdxz20nJk5m4ftDdv3ozf//732LBhA0aOHInLly/jueeew+zZs7F169ZbPmfVqlXIzc1t/x9oG9nqw/R371epVPf03K76AH+v90uS5PRHy7y8vKw/tyEhIZg4cSLi4uKsr9utA0OOaior4BcY1Oq2gvNn8dXubRg4elyHBih1JJejYZmhTuPl5YUePXqwzJBT6cjkmhbbVmeivKQYr6avsUGibzjz5BqeMnPzbV3pbh90/fz8EBERccdttByZudNpZgaDAW+//TYWLFiAiRMnAgCSkpLwt7/9DUOGDEF1dTX8/f1vet6wYcPQu3fvLvkA7wof3qm1sLAwhIeHY/To0UhISLjp/ffTqNp9pP4fP3kSand3JAwcAr/Abii+dBHb12ZD7e6BJT97qd2Z5W9zuQrXeaUkhE6nw8GDBzu0iI3InrRMrmnvP151VZVYvexvmPvUCzd9I9cRxTeqYK5xzlNmRH54t8U33kqlEm5ubjfdb+tTczrrW3pbuN1pZg0NDTCbzfD19YVSqYSPjw/y8/NhMBig0WhgNptx9OhReHp6QqPR3HLbLRdqJuoM/fv3v+M18/zd2z98ZdiEKfjikw3YnP4emhrq4BsQhOGTpmLeMz9FWHTH1uJ0JJejYZmhTqXVarFnzx4UFxcjOjpadByiDuvohJiV//wLvP398dCSx2yUCLCYzfjq+GmUnTrSrufb+rSUu50yY2+nynTGh3f6Rl1dHS5cuIDGxkYAwLFjx6BUKhEWFoaEhAT85Cc/wfXr17Fx40aoVCosWrQIaWlp+NWvfoVBgwbh6tWrePfdd5GWlgYPDw/Br4boZu4qJTRKRbtOP56W8gSmpTxh80wapcKlTjtmmaFOFR4eDk9PT+Tm5rLMkFPoyISYkoJ87FibjbRf/hpV18ustzc3G2A2GnG9+Ao8vL3h4x/Qpu0qlUr0HzAAcSMHtflDPD+8U2c6cuQIJk2aBJVKBU9PT7z22msAgMceewxvvvkmNBoNPL8zmvyRRx6BJEl49913sXnzZgQHB+NHP/oRfvrTnwp6BUR3F+7tjoKaxg4PhrEFCd/kcSWSzCtQUSfbuHEjSktL8eSTT4qOQtRhZ8prkVvZ0K5/tM4c/hKvLp1zx8dMS3kCj/3fb9q0XQmALtALfYJ925GKiIg6okZvxM7CG6JjWE2I6eZS1x7jkRnqdFqtFidPnkRtbS18fflhixxbRybERPVMwP+++f5Nt6/651/Q1FCPx/7vNwiNjOnyXERE1H5+7m4IdHezycWUO0ICEODu5lJFBmCZoS4QHx8PSZKQm5trvaozkaPqyOQa34AgDJ948/Uytiz/LwDc8r574WqTa4iI7I0u0BuHS6qEZpC/zeFq+FUedToPDw9EREQgLy9PdBSiDrPXCTH2mouIyBWEe2sQ5qWBqFWIEoAwbw3CvW899c+Z8as86hJarRYHDhzgiGZyeB2ZXHM7v8la36Hnu9rkGiIieyNJEgaG+mHb5XKYOjIppp2UCgkDQ/xccqgLj8xQl9DpdGhubkZRUZHoKEQdFu7tLuzbt+9zxck1RET2yF2lxKBQPyH7HhTq57JfavHIDHWJ0NBQeHt7Izc3F7GxHbsQFJFocf6euFzTKDoGgG/OkY4L8Lzr44iIyPZkWcaNGzdw/vx5HD58GH5+fhg3exFOldd2WYZ+wb6I8HHd6zCxzFCXkCQJWq0WeXl5mDx5sug4RB3CyTVERK7LYrGgsLAQFy5cwPnz51FTU2O9LyQkBNpALwDokkLTr7svtAFenb4fe8YyQ11Gp9PhxIkTqK6uhr+/v+g4RB3CyTVERK7p+PHj+OSTTyBJEr5/ucbx48cDALSBXnB3U+BYaQ3MFtmmF9SU8M0amUGhfi59RKYF18xQl4mLi4MkSZxqRk6Bk2uIiFxTr169EBAQcNPtAQEBCA8Pt/4+wscDk2ODEer1zX+nO/rvRcvzQ701mBwbzCLzLZYZ6jLu7u6IiopCbm6u6ChEHdYyuUapEFNnXHlyDRGRSF5eXpg/f36r//5KkoQBAwbc9N9kd5US9/UIwPDwAAR8O0K/rf/Vbnl8gLsbhocH4L7wAJdd7H8rPM2MupRWq8W+fftgMpmgUvHHjxxby+SaIyXVXb5vV55cQ0QkUn19PTZs2AA3NzdIkgS9Xg9ZltGvX79bPl6SJPTwcUcPH3fU6I3Ir25ESb3eOuL/VuWm5bQ0jVKBcG93xPl7wo/XE7slfpqkLqXT6bBz504UFhYiPj5edByiDovw8YA+2MLJNURELqCmpgaZmZlobm7G448/DlmW8cEHHyAkJOSe1gP7ubthYKgfBsIPepMZ1XojagwmGC0WWGRAIQFuCgX8NCr4u7vxS6t7wDJDXap79+7w8fFBbm4uyww5DU6uISJyfhUVFcjKyoIkSXjssces62aeeeYZKBRtX7nhrlIi1FuJUM5x6RCWGepSkiRBp9NxCAA5HU6uISJyXmVlZcjKyoKHhweSk5Ph6+trvc/Hx0dgMuIAAOpyOp0OFRUVqKysFB2FyKY6a3KNvwqcXENEJMjVq1eRkZEBHx8fpKamtioyJB7LDHW52NhYKBQKHp0hp2TryTVFB7bjixX/wbnTp266ngEREXWugoICZGZmIjg4GEuXLoWXF0/ztTcsM9TlNBoNoqOjOaKZnFbL5Jqx0d0wIbobYvw8oVH+///cSrf41UKjVCDGzxMTorthbHQ36K+XQJZlbNq0CatWrUJDQ0PXvhgiIheVm5uLFStWICIiAkuWLIG7u7voSHQLXDNDQmi1WuzevRtGoxFubhw1SM6ro5Nr3N3dYTAYAAB5eXl48803MXPmTPTq1UvEyyEicglnz57FRx99BJ1Ohzlz5vByEnaMR2ZICJ1OB5PJhIKCAtFRiLrMN5Nr3JEQ5I0+wb7o190XfYJ9kRDkjVBv91uO4Pxu2ZdlGXq9HmvWrMHJkye7MjoRkcs4fvw41q9fj6SkJMydO5dFxs6xzJAQ3bp1g5+fH081I7oLtVp9021hYWGIiIgQkIaIyLkdPnwYmzZtwqBBgzBr1iwolbzOi71j1SQhvjuiWZZlSFJH5z4ROafvl5n+/ftj5syZ/DtDRGRDsizjiy++wO7duzFixAhMmjSJ/511EDwyQ8LodDpUVVVxRDPRHfj5+UGj0eDBBx9E//79cfHiResaGiIi6jhZlrFjxw7s3r0b48aNY5FxMDwyQ8LExMRAqVQiNzcXQUFBouMQ2aXp06dj+vTpUKlUqK2txdmzZ3HgwAFMmDBBdDQiIocnyzK2bNmCr7/+GlOmTMF9990nOhK1EY/MkDBqtRoxMTFcN0N0ByqVyrr41NfXFyNGjMChQ4dQU1MjOBkRkWOzWCzYuHEjvv76a8yYMYNFxkGxzJBQWq0WhYWFaG5uFh2FyCGMGjUKarUae/bsER2FiMhhmUwmrFu3DmfOnMHs2bMxcOBA0ZGonVhmSCidTgez2YzLly+LjkLkEDQaDR544AGcOHECZWVlouMQETmc5uZmrFq1Cnl5eZg/fz769OkjOhJ1AMsMCRUYGIiAgACeakbUBoMHD0ZgYCC2b98uOgoRkUPR6/XIzs5GcXExFi9ejJ49e4qORB3EMkNCfX9EMxHdnVKpxMSJE3Hp0iVcunRJdBwiIofQ0NCA5cuXo7y8HMnJyYiJiREdiWyAZYaE02q1qKmpwY0bN0RHIXIYvXr1QmRkJHbs2MEvAoiI7qK2thYZGRmoq6tDamoqLzzsRFhmSLiYmBioVCqeakbUBpIkYdKkSSgtLcWpU6dExyEisltVVVVIT09Hc3Mz0tLSEBISIjoS2RDLDAnn5uaG2NhY5OXliY5C5FAiIyPRu3dv7Nq1CyaTSXQcIiK7U15ejvT0dCgUCjz22GO8rp0TYpkhu9AyoplXNidqmwkTJqC+vh6HDx8WHYWIyK5cu3YNGRkZ8PDwQFpaGvz8/ERHok7AMkN2QafTwWKxID8/X3QUIocSFBSEwYMH44svvkBjY6PoOEREdqGoqAjLly9HQEAAUlNT4e3tLToSdRKWGbILAQEBCAoK4qlmRO3wwAMPQJZlfPHFF6KjEBEJd+nSJWRnZyM0NBTJycnw8PAQHYk6EcsM2Q2tVovc3FxOZiJqIy8vL4waNQpHjhxBVVWV6DhERMKcP38eq1atQkxMDBYvXgyNRiM6EnUylhmyGzqdDnV1dbh+/broKEQOZ8SIEfDy8sKuXbtERyEiEuLUqVNYu3YtEhISMH/+fLi5uYmORF2AZYbsRnR0NNzc3Diimagd3NzcMHbsWJw5cwZXr14VHYeIqEt99dVX2LBhA/r374/Zs2dDqVSKjkRdhGWG7IZKpUJcXBzXzRC104ABAxAcHIzt27fzdE0ichkHDhzAli1bMGzYMMyYMQMKBT/euhK+22RXtFotioqKoNfrRUchcjgKhQKTJk1CYWEhj3ASkdOTZRm7du3Cjh07MHr0aDz44IOQJEl0LOpiLDNkV7RaLWRZxqVLl0RHIXJIWq0WMTEx2LFjBywWi+g4RESdQpZlfP755/jiiy8wceJEjB8/nkXGRbHMkF3x9/dHcHAwTzUjaidJkjBp0iSUl5fj+PHjouMQEdmcxWLBpk2bcOTIEUybNg2jRo0SHYkEYpkhu6PVapGXl8dz/onaKTw8HH379sWePXvQ3NwsOg4Rkc2YzWasX78eJ0+exKxZszBkyBDRkUgwlhmyOzqdDvX19SgtLRUdhchhjR8/Hk1NTTh48KDoKERENmE0GrFmzRpcuHAB8+bNQ79+/URHIjvAMkN2JyoqCmq1mguYiTrA398fw4YNw4EDB1BfXy86DhFRhxgMBqxYsQIFBQVYuHAhevXqJToS2QmWGbI7SqWSI5qJbGD06NFQKpXYu3ev6ChERO3W1NSErKwslJaWYsmSJYiPjxcdiewIywzZJZ1Oh+LiYjQ1NYmOQuSwPDw8MHr0aHz99de4ceOG6DhERG1WX1+PjIwMVFVVYenSpYiKihIdiewMywzZJY5oJrKNYcOGwdfXFzt37hQdhYioTWpqapCeno6mpiakpqYiLCxMdCSyQywzZJd8fX0REhLCdTNEHaRSqTB+/HicP38eRUVFouMQEd2TiooKfPDBB7BYLEhLS0NwcLDoSGSnWGbIbnFEM5Ft9O3bF2FhYdi+fTv/PhGR3SsrK0N6ejrUajXS0tIQEBAgOhLZMZYZsls6nQ6NjY0oKSkRHYXIobVcSLO4uBjnzp0THYeI6LaKi4uRkZEBHx8fpKamwtfXV3QksnMsM2S3IiMjodFoeKoZkQ3ExsZCq9Vi586dMJvNouMQEd2koKAAWVlZCA4OxtKlS+Hl5SU6EjkAlhmyWwqFAvHx8RzRTGQjkyZNQlVVFb766ivRUYiIWrl48SJWrFiBiIgILFmyBO7u7qIjkYNgmSG7ptPpcPXqVTQ0NIiOQuTwunfvjv79+2Pfvn3Q6/Wi4xARAQDOnj2LNWvWQKvVYuHChVCr1aIjkQNhmSG7ptVqAYAjmolsZNy4cWhubsaBAwdERyEiwvHjx7F+/Xr06dMHc+fOhUqlEh2JHAzLDNk1b29vhIWFcd0MkY34+vpixIgROHToEGpra0XHISIXdujQIWzatAmDBg3CI488AoWCH0up7fhTQ3ZPq9Xi0qVLsFgsoqMQOYVRo0ZBrVZj9+7doqMQkQuSZRl79+7F1q1bMXLkSEybNg2SJImORQ6KZYbsnk6nQ1NTE65evSo6CpFT0Gg0eOCBB3DixAmUlZWJjkNELkSWZWzfvh179uzBuHHjMHHiRBYZ6hCWGbJ7PXr0gIeHB081I7KhwYMHIzAwEDt27BAdhYhchMViwZYtW3Dw4EE8+OCDGDNmDIsMdRjLDNk9jmgmsj2lUokJEyYgLy8P+fn5ouMQkZMzm83YuHEjjh07hhkzZmD48OGiI5GTYJkhh6DT6XDt2jXU19eLjkLkNHr37o2IiAhs374dsiyLjkNETspkMmHdunU4e/YsZs+ejYEDB4qORE6EZYYcQnx8PADw6AyRDUmShEmTJqG0tBSnT58WHYeInFBzczNWrVqFS5cuYcGCBUhKShIdiZwMyww5BC8vL/To0YPrZohsLCoqCr169cKuXbtgMplExyEiJ6LX65GdnY3i4mIsXrwYOp1OdCRyQiwz5DA4opmoc0ycOBG1tbU4fPiw6ChE5CQaGhqwfPlylJeXIyUlBTExMaIjkZNimSGHodPpYDAYcOXKFdFRiJxKUFAQBg8ejC+++AKNjY2i4xCRg6utrUVGRgbq6uqQmpqKHj16iI5EToxlhhxGeHg4PD09eaoZUSd44IEHIMsyvvjiC9FRiMiBVVVVIT09HUajEWlpaQgJCREdiZwcyww5DEmSoNVqOQSAqBN4e3tj1KhROHr0KKqqqkTHISIHVF5ejg8++AAKhQJpaWkICgoSHYlcAMsMORStVouysjLU1taKjkLkdO677z54eHhg165doqMQkYMpKSlBeno6PD09kZaWBj8/P9GRyEWwzJBDiY+PhyRJPDpD1AnUajXGjRuHM2fOoKSkRHQcInIQRUVFyMzMRGBgIFJTU+Ht7S06ErkQlhlyKJ6enoiIiGCZIeokAwYMQHBwMLZt28YLaRLRXV26dAlZWVkICwtDcnIyPDw8REciF8MyQw6nZUSz2WwWHYXI6SgUCkycOBGFhYUctkFEd3Tu3DmsWrUKsbGxWLRoETQajehI5IJYZsjh6HQ6NDc3o6ioSHQUIqek0+kQExODHTt28LpORHRLJ0+exLp169CrVy/Mnz8fbm5uoiORi2KZIYcTGhoKb29vfmtM1EkkScKkSZNQXl6OEydOiI5DRHbm6NGj2LhxI/r3749HH30USqVSdCRyYSwz5HA4opmo84WHh6NPnz7YvXs3mpubRcchIjuxf/9+fPrppxg+fDhmzJgBhYIfJUks/gSSQ9JqtSgvL0d1dbXoKEROa/z48WhqasLBgwdFRyEiwWRZxs6dO7Fz506MGTMGU6ZMgSRJomMRscyQY+KIZqLOFxAQgKFDh+LLL79EfX296DhEJIgsy/j888+xf/9+TJo0CePGjWORIbvBMkMOyd3dHVFRUSwzRJ1szJgxUCgU2Lt3r+goRCSAxWLBpk2bcOTIEUybNg0jR44UHYmoFZYZclharRb5+fkwmUyioxA5LQ8PD4wePRpff/01bty4IToOEXUhs9mM9evX4+TJk5g1axaGDBkiOhLRTVhmyGHpdDoYjUYUFhaKjkLk1IYNGwZfX1/s3LlTdBQi6iJGoxGrV6/GhQsXMG/ePPTr1090JKJbYpkhh9W9e3f4+PjwVDOiTqZSqTB+/HicP3+e13cicgEGgwErVqxAYWEhFi1ahF69eomORHRbLDPksFpGNPN6M0Sdr2/fvggNDcX27dshy7LoOETUSRobG5GZmYnS0lIkJycjLi5OdCSiO2KZIYem0+lQUVGBqqoq0VGInFrLhTSLi4tx7tw50XGIqBPU1dUhIyMD1dXVWLp0KSIjI0VHIrorlhlyaHFxcVAoFDw6Q9QF4uLioNVqsXPnTpjNZtFxiMiGqqurkZGRAb1ej9TUVISFhYmORHRPWGbIoWk0Go5oJupCEydORGVlJb7++mvRUYjIRm7cuIH09HRYLBakpaUhODhYdCSie8YyQw5Pp9Ph8uXLMBqNoqMQOb2QkBAMGDAAe/fuhcFgEB2HiDqotLQUGRkZUKvVSEtLQ0BAgOhIRG3CMkMOT6fTwWQycUQzURcZN24cmpubsX//ftFRiKgDiouLsXz5cvj6+iItLQ2+vr6iIxG1GcsMObxu3brBz8+P62aIuoivry/uu+8+HDp0CLW1taLjEFE7XL58GZmZmQgODkZKSgo8PT1FRyJqF5YZcngc0UzU9UaNGgW1Wo3du3eLjkJEbXTx4kWsWLECUVFRWLJkCdzd3UVHImo3lhlyCjqdDlVVVaioqBAdhcgluLu744EHHsCJEydQVlYmOg4R3aMzZ85gzZo10Ol0WLBgAdRqtehIRB3CMkNOITY2FkqlkkdniLrQ4MGDERgYiB07doiOQkT34NixY1i/fj369OmDuXPnQqVSiY5E1GEsM+QU1Go1oqOjOaKZqAsplUpMmDABeXl5yM/PFx2HiO7g4MGD2Lx5M4YMGYJHHnkECgU/ApJz4E8yOQ2dToeCggI0NzeLjkLkMnr37o2IiAhs374dsiyLjkNE3yPLMvbs2YNt27Zh1KhRmDp1KiRJEh2LyGZYZshpaLVamM1mFBQUiI5C5DIkScKkSZNQWlqK06dPi45DRN8hyzK2b9+OvXv3Yvz48Zg4cSKLDDkdlhlyGkFBQQgICOC6GaIuFhUVhV69emHXrl0wmUyi4xARAIvFgk8++QQHDx7Egw8+iNGjR4uORNQpWGbIaXx3RDNPdyHqWhMmTEBtbS2OHDkiOgqRyzObzdiwYQOOHz+OmTNnYvjw4aIjEXUalhlyKjqdDjU1Nbhx44boKEQupVu3bhg8eDC++OILNDU1iY5D5LJMJhPWrl2LnJwczJkzBwMGDBAdiahTscyQU4mJiYFKpeKpZkQCPPDAA7BYLNi3b5/oKEQuqbm5GStXrkR+fj4WLFiAxMRE0ZGIOh3LDDkVNzc3xMTEcEQzkQDe3t4YOXIkjh49iqqqKtFxiFxKU1MTsrKycPXqVSxevBg6nU50JKIuwTJDTken06GwsBAGg0F0FCKXM2LECHh4eGD37t2ioxC5jIaGBixfvhw3btxASkoKYmJiREci6jIsM+R0tFotLBYLLl++LDoKkctRq9UYN24cTp8+jZKSEtFxiJxeTU0N0tPTUV9fj9TUVPTo0UN0JKIuxTJDTicwMBBBQUFcN0MkyIABAxAcHMwLaRJ1ssrKSqSnp8NkMiEtLQ0hISGiIxF1OZYZckparRZ5eXn8IEUkgEKhwMSJE1FQUMD1a0Sd5Pr160hPT4dKpUJaWhqCgoJERyISgmWGnJJOp0NtbS2uX78uOgqRS9LpdIiJicH27dthsVhExyFyKiUlJcjIyICXlxdSU1Ph5+cnOhKRMCwz5JSio6Ph5ubGU82IBJEkCRMnTkRFRQWKi4tFxyFyGnV1dVi+fDkCAwOxdOlSeHt7i45EJJQk8zwcclKrVq2CwWBAamqq6ChELqu+vh5eXl4Avik4RNRxOTk5iI+Ph0ajER2FSDgemSGnpdVqUVRUBL1eLzoKkcvy8vKCJEksMkQ2lJiYyCJD9C2WGXJaOp0OsiwjPz9fdBQil8USQ3Tvvv76a9ERiBwOyww5LX9/fwQHB3PdDJEdMxqNOHr0KAoLC9HU1CQ6DpEwr776KoYOHYqioiLRUYgcCssMOTWOaCayTzdu3MCLL76I8PBwPPbYY+jbty/S0tJw4cIF0dGIutz//u//4vXXX8eOHTsQFRUlOg6RQ1GJDkDUmXQ6HQ4ePIjS0lKEhYWJjkNEAP7zn//gxRdfhK+vL/7nf/4HgwYNQm1tLTZs2ICUlBQcPnxYdESiLvPjH/8Yy5cvx4EDB9C3b19cvnwZFRUVqKmpQa9evdCjRw8AgCzLPG2T6BZYZsipRUVFQa1WIzc3l2WGSLDm5ma8/PLLeO+99/DMM8/g2WefRWhoqPUDWv/+/TFixAgcO3YMgwYNEpyWqPMVFxdjy5Yt0Gq16Nu3L3bu3IlnnnkGCoUC58+fx4gRI7Bo0SI888wzLDJEt8HTzMipKZVKxMXF8SrkRHbg3LlzWLt2Lf7whz/gpZdeQlhYWKsPaKWlpejWrRuvZE4uIzw8HJmZmSgtLUVSUhJ+9KMf4Qc/+AE++ugjHDt2DAMGDMDbb7+N7du3i45KZLdYZsjpabVaFBcXc3ExkWAHDx5EcHAwlixZAk9Pz1b3HTlyBM8++yy6d++O7t27C0pI1LUUCgVGjhyJzMxMSJKEuXPn4qc//Sl69eqFAQMG4Cc/+QlMJhNOnTolOiqR3eJpZuT0WkY0X7p0CX369BEdh8hl6fV6mEwm+Pj4WG8rKirCtm3b8PHHHyMoKAhvvPEGPDw8BKYk6npjxoxBZmYmfHx8Wh2t1Gq18Pb2Rm1trcB0RPaNZYacnq+vL7p37468vDyWGSKBXnjhBfzxj3/E448/jrFjx+LChQvIy8vD2bNnERsbi9deew19+/YVHZOoy6lUKgwYMAAKResTZvLz82E2m/n3gugOeJoZuQSdTofc3FyOaCYSbMWKFVAoFHj22WexZ88eqFQq/OIXv8DmzZsxevRo0fGIOoUsy3f99+e7Raa+vh4nT57ErFmzEBsbizlz5nR2RCKHJcn8dEcuoLCwEBkZGXjiiSesYy6JSAyTyYTm5mbIsgw3Nzeo1WoAgNlshlKphMVigSRJkCSJ42jJ4VVWVuLll1/GkiVLMHLkyDs+VpZl1NTU4J133sHatWvRs2dPrF69uouSEjkmnmZGLiEiIgIajQZ5eXksM0SCqVQqqFQqnDp1Cv369QMAWCwWKJVKa6EBgIaGBnh5eYmMStQh5eXlmDRpEk6dOoUzZ87g3//+9x1Pd5YkCf7+/hg9ejQSEhIwa9asLkxL5Jh4mhm5BKVSifj4eOTm5oqOQkQA3nrrLTz88MP46KOPAPz/U2yUSiVqamrw5JNPYsaMGXjuueewbds2kVGJ2sVoNOL9999HVFQUDh48iMLCQjzzzDO4cOHCLR+/e/du/OEPfwAAjBo1ikWG6B6xzJDL0Gq1uHr1KhoaGkRHIXJ5EydOxOTJkxEZGdnq9pKSEjz00EP46quvMHz4cBQWFuL555/Hl19+KSgpUfuoVCoMGTIE8+bNw/Dhw/HVV1/h/PnzeOGFF3Dp0iXr42RZhsFgwKeffoply5bxZ52ojbhmhlxGXV0d/vGPf2DWrFnWU1uISJxbrYfZtm0bnnjiCbz//vuYNGkSAOCXv/wltm3bhq+//lpETKJ2+/7PeH5+PgYNGoTx48fjjTfeQFRUFACgsbERBoMBJ06cwLhx40TFJXJIPDJDLsPHxwehoaHIy8uD3mRGab0eFyrqcaa8Fqeu1+JMeS0uVNSjtF4PvcksOi6R05MkCQ0NDTh9+jQaGxsBAOfOnYOfnx8mTZpknf60cOFCSJKEK1euiIxL1GbfLTJmsxlxcXHYu3cvPv/8c7z00ksoKSnBf//7XzzyyCMwm80sMkTtwCMz5DJq9EYcOHcJjSoNFGp3AMCtZiS1/IXQKBUI93ZHnL8n/NzduiwnkSs5duwY3nzzTfziF79Az549UV5ejpCQEBw9ehSDBw8GAPzkJz/B7t27cejQIbi7uwtOTNR+JpMJKpUKBw8exMSJE5GQkIATJ07g/fffR1pamuh4RA6JZYacmizLKKk34GJlPar0Rkj4/2XlXrQ8PtDdDbpAb4R7azgmlsiGGhsbER4ejuzsbEyfPh0A8H//93/YtWsXHnroIdTU1ODgwYN47rnnsGjRIsFpiTrOYrFAoVAgOTkZK1aswMaNGzFjxgzRsYgcFkczk9PSm8w4XlqDaw0G621tbe4tj6/SG3G4pAphXhoMDPWDu0pps5xErszT0xPPPfccXnrpJajVakyePBlPPfUUVCoVfv3rXwMAHn/8cTz44IOCkxK1zZ2ukfTaa69hxYoV2Lp1q3VtGBG1D4/MkFMqrmvCsdIamC1ymwvMnUgAlAoJg0L9EOHjYcMtE7m25ORkHD58GAaDAcHBwSgrK4OnpyeWLVuGKVOmiI5H1CZnz55Fr169oFAobio0FosFK1euRFxc3F0voklEd8cyQ04nt7Iep8vrOn0//YJ9oQ3kBf2IbKG5uRmnTp3C0aNH0djYiOjoaMyZM8d6/52+5SayF7IsY+/evdi7dy8eeeQR9OvXjz+3RJ2MZYacSlcVmRYsNESdq2V9AZG9k2UZ27Ztw6FDhzB+/HiMHj1adCQil8A1M+Q0iuuaurTIAMCp8lq4uyl4yhmRjbUciWGRIUdgsVjwySef4Pjx43jooYcwbNgw0ZGIXAbLDDkFvcmMY6U1QvZ9rLQG3TzUHApAZEM8NYcchdlsxoYNG5CTk4OZM2diwIABoiMRuRR+5UUOT5ZlHP92sb8IZouM42U14BmbRLbHv1dkz4xGI9auXYtz585hzpw5LDJEArDMkMMrqTfgWoPBplPL2kIGcK3egJJ6w10fS0T3RpZlmM1mnD17loWG7FJzczNWrlyJ/Px8LFy4EImJiaIjEbkknmZGDi+3sr5dz2tqaMDH7/8buaeOI+/0CdTXVOOZP7yO8Y/Ob/O2pG9z9PDh1cmJbEGSJBQUFGD9+vXQaDTQ6XSiIxFZNTU1YeXKlbh+/TqWLFmC6Oho0ZGIXBaPzJBDq9EbUak3tuu5dVWVWPfv11Gcn4vohI59oyYDqNQbUWNoXxYiullcXByio6OxY8cOWCwW0XGIAAD19fVYvnw5KioqsHTpUhYZIsFYZsih5Vc3or3LhAO6d8d/vziBd3cdRcrPf9XhLBKA/KrGDm+HiL4hSRImTZqE69ev4+TJk6LjEKGmpgYZGRloaGhAamoqwsPDRUcicnksM+TQSur17V4r46bWICC4u82yyN/mISLb6dGjB5KSkrB79240NzeLjkMurLKyEunp6TCZTEhLS0P37rb794OI2o9lhhyW3mSGwWxfp54YzBboTWbRMYicyoQJE9DQ0IBDhw6JjkIu6vr160hPT4dKpUJaWhoCAwNFRyKib7HMkMOqbudamc5mr7mIHFVAQACGDh2KAwcOoKGhQXQccjFXr15FRkYGvLy8kJaWBj8/P9GRiOg7WGbIYdUYTO1eL9NZJHyTi4hsa8yYMZAkCXv37hUdhVxIYWEhMjMzERQUhKVLl8LLy0t0JCL6HpYZclhGO51uZK+5iByZp6cnRo8eja+//hoVFRWi45ALyM3NRXZ2Nnr06IHk5GR4eHiIjkREt8AyQw7LYqfX0bPXXESObtiwYfD29sbOnTtFRyEnl5OTg9WrVyMuLg6LFi2CWq0WHYmIboNlhhyWwt7OMfuWveYicnRubm4YP348zp07hytXroiOQ07qxIkT+PDDD5GYmIh58+ZBpeL1xYnsGcsMOSw3hX3++NprLiJn0K9fP4SEhGD79u2QZR4GJds6fPgwPv74YwwYMACzZs2CUqkUHYmI7oJfN5DD8tOo2n2NmRafZn+AxrpaVF4vAwB8tXs7KsuuAQAeWvIYvHx827Q9+dtcRNQ5Wi6kmZ2djfPnz6N3796iI5GT+OKLL7Br1y7cd999mDx5MiSJh9mJHIEk86stclB6kxmfXrreoW08OX4YykuKb3nf2zsOo3tEZJu3OTW+O9xV/DaPqDNlZ2ejqqoKTz/9NL89pw6RZRk7d+7EgQMH8MADD+CBBx5gkSFyICwz5NC25JXZ1YUzFWYTxoR68YJqRJ2stLQU7777LqZOnYqhQ4eKjkMOSpZlfPrpp/jqq68wefJkjBgxQnQkImojng9DDi3c2x0FNY0dPt3MJmQZFQV5+Ne6fQgLC0NSUhISExMREBAgOhmR0wkNDUX//v2xZ88e9OvXDxqNRnQkcjAWiwUff/wxTp06henTp2Pw4MGiIxFRO/DIDDm0Gr0ROwtviI5hNaaHH8oKLyMnJwcXL16EyWRCeHi4tdj4+/uLjkjkNGpqavDmm29ixIgRGD9+vOg45EBMJhPWr1+PixcvYtasWejTp4/oSETUTiwz5PD2FN5Apd4oNIMEIMDdDWOju1lva25uxsWLF5GTk4Pc3FyYTCb06NEDiYmJSEpKgp+fn7jARE5ix44dOHz4MJ5//nn4+PiIjkMOoLm5GWvXrkVBQQHmzp2LhIQE0ZGIqANYZsjhXa3T43BJlegYGB4egB4+7re8z2AwtCo2ZrMZERERSExMRGJiIosNUTvp9XosW7YMvXr1wowZM0THITun1+uxatUqXLt2DQsXLkRsbKzoSETUQSwz5PBkWcahq1UobTAIWTsjAQj11uC+8IB7moDTUmzOnj2LvLw8mM1mREZGWouNr2/bxkETubrDhw9j69atePLJJ9G9e3fRcchONTY2WqfgLV68GBEREaIjEZENsMyQU9CbzNh2uRwmS9f/OKsUEibHBrdrHLNer7cWm0uXLlmLTcsaG542Q3R3ZrMZb731Frp164ZFixaJjkN2qK6uDllZWWhoaEBycjJCQ0NFRyIiG2GZIadRXNeEIyXVXb7fYeH+iPDx6PB29Ho9Lly4YC02FosFUVFRSEpKQu/evVlsiO7g7Nmz+PDDD5GSksJTh6iVqqoqZGVlwWw2Izk5Gd26dbv7k4jIYbDMkFPJq2zAqfLaLttfv2BfaAO9bL7dpqYmXLhwATk5OdZiEx0dbT0Vzdvb2+b7JHJksizj/fffh8ViwQ9+8ANe9JAAAOXl5cjKyoJKpUJKSgonShI5IZYZcjpdVWj6dfeFNsD2Reb7mpqacP78eeTk5CA/Px8WiwUxMTFITExE7969WWyIvlVYWIiMjAw8+uij6Nu3r+g4JNi1a9eQnZ0NLy8vJCcn8+g2kZNimSGnVFzXhGOlNTBbZJsOBZAAKBUSBoX62eTUsrZqbGxsVWwAtCo2Xl6dX66I7Nnq1atRVlaGZ555BioVrwvtqoqKirBy5UoEBQVh8eLF8PT0FB2JiDoJyww5Lb3JjOOlNbjWYIAEdKjUtDw/zFuDgSF+7Vrsb2uNjY04d+4ccnJycPnyZQBAbGystdjwH29yRTdu3MC///1vTJo0CSNGjBAdhwTIz8/H6tWrERYWhkWLFkGj0YiORESdiGWGnJosyyipNyC3sh6VemObS03L4wPd3aAL9Ea4t8Yuz8VvaGjA+fPncfbsWRQUFAD4ptgkJSWhV69eLDbkUj755BOcPXsWzz//PDw8uv4IKolz/vx5fPjhh4iNjcW8efPg5uYmOhIRdTKWGXIZNXoj8qsbUVKvh8FsAfBNWfm+lr8QGqUC4d7uiPP3hJ+74/yD2NDQgHPnzuHs2bMoLCwEAMTFxVmLDT/ckbOrr6/HsmXLMGTIEEyePFl0HOoip06dwsaNG9GrVy/Mnj0bSqX4I+hE1PlYZsgl6U1mVOuNqDGYYLRYYJEBhQS4KRTw06jg7+5mF6eSdVR9fb31VLSCggIoFArExcUhMTGRxYac2p49e7B//348++yznGDlAr766its2bIF/fv3x4wZM6BQKERHIqIuwjJD5CLq6uqsxaawsBAKhQLx8fHWYuPu7i46IpHNNDc341//+hfi4uIwa9Ys0XGoE3355ZfYvn07hg4dioceesguTwUmos7DMkPkgurq6pCTk4OcnBwUFRVBoVBAq9UiMTERCQkJLDbkFL7++mt88skn+OEPf4iwsDDRccjGZFnGnj17sG/fPtx///0YP348iwyRC2KZIXJxtbW11jU2V65cgVKpbFVsOAmIHJXFYsHbb78NHx8fJCcn84OuE5FlGVu3bsXhw4cxYcIE3H///aIjEZEgLDNEZFVbW4ucnBycPXsWxcXF1mKTlJSEnj17stiQw7lw4QJWr16NRYsWQafTiY5DNmCxWPDJJ5/g+PHjmDp1KoYOHSo6EhEJxDJDRLdUU1NjLTZXr16FUqmETqezFhu1Wi06ItFdybKM5cuXo6mpCT/60Y+4MNzBmc1mbNiwATk5OZg5cyb69+8vOhIRCcYyQ0R3VV1dbV1jc/XqVahUKmux0el0LDZk165evYr//ve/mDFjBgYOHCg6DrWT0WjEunXrcOnSJcyZMwe9e/cWHYmI7ADLDBG1SVVVlbXYlJSUQKVSoWfPnkhMTGSxIbv14YcfoqioCM899xwvpOiADAYDVq9ejeLiYsyfPx9arVZ0JCKyEywzRNRuVVVVOHv2LHJycnDt2jW4ubm1Kjb80Ej2orKyEm+99RbGjh2L0aNHi45DbdDU1IQVK1bgxo0bWLhwIaKjo0VHIiI7wjJDRDZRWVlpXWNTWloKNzc3JCQkIDExEVqtlsWGhPv8889x/PhxPP/88/Dy8hIdh+5BfX09srKyUFdXhyVLliA8PFx0JCKyMywzRGRzFRUV1mJTVlYGtVqNnj17IikpCVqtFiqVSnREckGNjY1YtmwZ+vXrh6lTp4qOQ3dRU1ODzMxMNDc3Izk5Gd27dxcdiYjsEMsMEXWqGzduWIvN9evXoVarkZCQgKSkJMTHx7PYUJfav38/du/ejaeffhpBQUGi49BtVFRUIDMzEwqFAsnJyQgMDBQdiYjsFMsMEXWZGzduWNfYXL9+HRqNxnoqGosNdQWj0Yg333wTERERmDt3rug4dAtlZWXIysqCu7s7UlJS4OvrKzoSEdkxlhkiEqK8vBxnz57F2bNncePGDWg0GvTq1ctabJRKpeiI5KROnjyJjRs34rHHHkNkZKToOPQdV69eRXZ2Nvz9/bFkyRKubSKiu2KZISLhrl+/bj1ic+PGDbi7u1uLTVxcHIsN2ZTFYsF7770HtVqNtLQ0SJIkOhIBKCgowKpVq9C9e3csXrwY7u7uoiMRkQNgmSEiuyHLMq5fv25dY1NRUWEtNklJSYiNjWWxIZu4dOkSsrOzMX/+fPTq1Ut0HJeXm5uLtWvXIjIyEgsWLOD1qojonrHMEJFdaik2LaeiVVZWwsPDw1psYmJiWGyoQ7Kzs1FdXY2nnnqKP0sCnT17Fh999BF0Oh3mzJnDtXNE1CYsM0Rk92RZRllZmbXYVFVVwcPDA71797YWG4VCITomOZjS0lK8++67mDp1KoYOHSo6jks6fvw4Nm/ejD59+mDmzJkslUTUZiwzRORQZFlGaWmpdY1NVVUVPD09Wx2xYbGhe7Vx40bk5eXhueeeg0ajER3HpRw+fBiff/45Bg0ahGnTpvHvLRG1C8sMETksWZZx7do1a7Gprq6Gp6en9YhNdHQ0PyDRHdXU1OBf//oXRo0ahXHjxomO4xJkWcYXX3yB3bt3Y8SIEZg0aRKHMBBRu7HMEJFTkGUZJSUl1mJTU1MDLy8va7GJiorqULExGAwwGo3w9va2YWqyBzt27MCRI0fw3HPPwcfHR3QcpybLMnbs2IEvv/wSY8eOxZgxY1hkiKhDWGaIyOnIsoyrV69ap6LV1tbC29vbWmwiIyPbXGz+/ve/Y/PmzdDr9Xj00UfxxBNP8KrkTkKv12PZsmXo1asXZsyYITqO05JlGVu2bMHXX3+NKVOm4L777hMdiYicAMsMETm1lmLTcsSmpdgkJiZai83dvhmWZRm/+tWv0L9/fxQWFmLz5s1QKBRYtWoVQkNDu+iVUGc6dOgQtm3bhieffBLdu3cXHcfpWCwWfPzxxzh16hQefvhhDBo0SHQkInISLDNE5DJkWUZxcbG12NTV1cHHxweJiYno168fwsPD72k7V65cwbRp0zBp0iT8/e9/7+TU1BXMZjPeeustBAcHY+HChaLjOBWTyYT169fj4sWLmDVrFvr06SM6EhE5EQ5zJyKXIUkSIiMjERkZiSlTpuDKlSvWcc8KhQKhoaG3PP3MYrFAkiRIkoTm5mZERkZCp9OhsLDQej8HDTg2pVKJCRMm4MMPP0RBQQFiYmJER3IKzc3NWLNmDQoLCzF//nz07NlTdCQicjI8MkNELk+WZTQ3N0OtVt/TYuQTJ05g1KhReP311/HDH/7wto8rLS3F3r17UVNTg7lz5yIgIMCWscnGZFnGf//7XwDAE088wYXpHaTX67Fy5UqUlpZi4cKFiI2NFR2JiJwQywwR0R1896hLTU0N3nnnHfznP/+BTqfDZ599dtPjZVmGJEk4cuQIUlJS4O3tjebmZhQVFeH1119HWlpaV78EaoPCwkJkZGRg9uzZPB2qAxoaGpCdnY3q6mosXrwYERERoiMRkZPieRFERHegUChQWVmJf/7znxg6dCg2bNiAF198EZs2bQLwTdlp0VJkysrK8MILLyA+Ph4ffvghTp48iVdffRV/+tOfUFxcLOql0D2Ijo5GQkICdu7cCZPJJDqOQ6qtrUVGRgbq6uqQmprKIkNEnYplhojoNsxmM95++23MmjUL//znP/Hiiy9iz549+MEPfgA3NzcAaLVWxmw2AwAyMjJQVVWFX/7yl4iJiYEkSZg2bRquX7+OK1euCHktdO8mTJiAmpoaHD16VHQUh1NVVYX09HQ0NzcjLS0NISEhoiMRkZNjmSEiuo19+/bhmWeeQW1tLfbv34/HH38c7u7uNz3OYrFAlmVrsUlPT8e4ceMwYMAA62MqKysRFxeHc+fOdVV8aqfg4GAMHDgQ+/btQ1NTk+g4DqO8vBzp6elQKBRIS0tDUFCQ6EhE5AJYZoiIbqN///7461//CoPBgJiYGIwZMwbvvPMOGhoaWj1OoVBAkiQoFAoUFxfjypUrmDRpEry9va2PKSsrw/Xr15GUlNTVL4PaYdy4cTCbzdi/f7/oKA7h2rVryMjIgIeHB9LS0uDv7y86EhG5CJYZIqLbCAwMxM9+9jPk5OTg4sWLGDNmDF599VW88cYb1kLz1ltv4Z133kFNTQ0A4MCBA4iNjW11Mc3GxkYcOXIEKpUKw4cPF/JaqG28vb0xcuRIHD58GNXV1aLj2LWioiIsX74c/v7+SE1NbVXiiYg6G8sMEdE9iImJwe9+9zuUlZXhpz/9Kby8vGA2m5GdnY3169dDqVQCAEJDQ9HU1ASNRmN97pkzZ7Bv3z7MnDlTVHxqh5EjR8Ld3R27d+8WHcVuXbp0CdnZ2QgNDUVKSgo8PDxERyIiF8MyQ0TURh4eHpBlGUqlEhs3bsQf//hH67fRCQkJMJlMOHz4MIBvRtT+9a9/hclkwuOPP37TtlqGBpD9UavVGDt2LE6dOoVr166JjmN3zp07h1WrViE6OhqLFy9uVeCJiLoKrzNDRGRj//3vf/Hzn/8cffv2hUKhwKlTp7B+/XqMGzeu1eMsFgsOHDiA06dPIykpCUlJSejWrZug1HQrFosF//73v+Hr64vk5GReSPNbp06dwsaNG9G7d288+uij1iOTRERdjWWGiKgT5OXlYcWKFQgKCsKUKVOg0+lu+biCggIcP34c58+fR3NzM7p3746kpCQkJiay2NiJ8+fPY82aNVi8eDG0Wq3oOMJ99dVX2LJlCwYMGICHH3641XhyIqKuxjJDRGQHTCYT8vLykJOTgwsXLqC5uRkhISFITExEUlISx9wKJMsyMjIyoNfr8aMf/cilP7wfOHAAO3bswLBhw/Dggw/ySBURCccyQ0RkZ4xGY6tiYzQaERoaai02gYGBoiO6nOLiYrz//vuYOXNmq+sHuQpZlrF792588cUXGD16NMaNG8ciQ0R2gWWGiMiOtRSbs2fP4uLFizAajQgLC7MWm4CAANERXca6detw5coVPPfcc3BzcxMdp8vIsozPP/8cR44cwcSJEzFq1CjRkYiIrFhmiIgchNFoRG5urrXYmEwmhIWFWdfYsNh0rsrKSrz11lsYO3YsRo8eLTpOl7BYLNi8eTNOnDiBqVOnYujQoaIjERG1wjJDROSAmpubrcUmNzcXJpMJ4eHh1mLDK7B3js8++wwnTpzA888/Dy8vL9FxOpXZbMZHH32Ec+fO4ZFHHkG/fv1ERyIiugnLDBGRg2tubsbFixeRk5NjLTY9evSwnorm5+cnOqLTaGxsxLJly9C/f3889NBDouN0GqPRiLVr1+Ly5cuYPXs2evfuLToSEdEtscwQETkRg8HQqtiYzWZEREQgMTERiYmJLDY2sH//fuzevRvPPPOMUw5jMBgMWLVqFa5evYoFCxYgPj5edCQiottimSEiclIGgwEXLlxATk4O8vLyYDabERkZaS02vr6+oiM6JKPRiDfffBMRERGYO3eu6Dg21dTUhOzsbFRUVGDRokWIiooSHYmI6I5YZoiIXIBer8fFixdx9uxZXLp0CWazGVFRUdZi4+PjIzqiQzlx4gQ+/vhjPP7444iIiBAdxybq6+uRlZWFuro6JCcnIywsTHQkIqK7YpkhInIxer0eFy5csBYbi8WCqKgoJCUloXfv3iw298BiseC9996DRqNBamqqw19zpbq6GllZWTAajUhOTkZwcLDoSERE94RlhojIhTU1NVlPRWspNtHR0dZi4+3tLTqi3crLy8OKFSswf/589OrVS3ScdquoqEBmZiYUCgVSUlI44puIHArLDBERAfim2Jw/fx45OTnIz8+HLMuIjo5GYmIii81tZGVloaamBk899RSUSqXoOG1WVlaGrKwseHh4IDk5meuoiMjhsMwQEdFNGhsbWxUbAIiJibEWG2e/xsq9unbtGt577z1MmzYNQ4YMER2nTYqLi7FixQr4+/tjyZIlfE+JyCGxzBAR0R01Njbi3LlzyMnJweXLlwEAsbGx1mLj6ekpOKFYGzZswKVLl/Dcc89Bo9GIjnNPLl++jFWrViE0NBSLFi2Cu7u76EhERO3CMkNERPesoaEB58+fx9mzZ1FQUAAAiIuLQ2JiInr16uWSxaampgb/+te/MGrUKIwbN050nLu6ePEi1q1bh6ioKMyfPx9qtVp0JCKidmOZISKidmloaMC5c+dw9uxZFBYWQpIkxMbGIikpCb169YKHh4foiF1m+/btOHr0KJ577jm7ngZ35swZbNiwATqdDnPmzIFKpRIdiYioQ1hmiIiow+rr662nohUUFEChUCAuLg5JSUlISEhw+mKj1+uxbNky9O7dGw8//LDoOLd07NgxbN68GX379sXMmTMdcmABEdH3scwQEZFN1dfXIycnBzk5OSgsLIRCoUB8fLz1VDRnXZ9x6NAhbNu2DU899ZTdXafl0KFD2Lp1KwYPHoxp06Y5/HVxiIhasMwQEVGnqaursxaboqIiKBQKaLVaJCYmIiEhwamKjclkwltvvYXu3btj4cKFouMAAGRZxr59+7Bnzx6MHDkSEydOZJEhIqfCMkNERF2itrbWusbmypUrUCqVrYqNo0wCu5MzZ85g/fr1WLp0KWJiYoRmkWUZ27dvx8GDBzFu3DiMHj2aRYaInA7LDBERdbna2lrk5OTg7NmzKC4uthabpKQk9OzZ02GLjSzL+O9//wsAeOKJJ4SVB4vFgk8//RRff/01pkyZgvvuu09IDiKizsYyQ0REQtXU1FiLzdWrV6FUKqHT6azFxtFGBxcUFGD58uWYPXs2+vTp0+X7N5vN+Pjjj3HmzBk8/PDDGDhwYJdnICLqKiwzRERkN6qrq61rbK5evQqVSmUtNjqdzmGKzapVq3D9+nU888wzXTr+2GQy4cMPP0Rubi4effRRJCUlddm+iYhEYJkhIiK7VFVVZS02JSUlUKlU6NmzJxL/X3t3FxtVWsdx/HdmOp3TdmD6AnYoGEtpKZkqocQVkr3RjUIQs5qoxBJgCdkb9oLExKyJxmzUmKwXhgtM8FZLUNYoJs1mI4mKrDGocVdZCjEUUFJKp9NOZzp9OdN5OV5AR1nKLvPSmXna7+eSds7zn5tOvsx5nhMO13zYRKNRnT17Vvv27Vv2Fi8nk1XcSSuRyiidyynnSh5L8nk8Cvrr1Gz7ZNcVdnTy4uKiLly4oHv37unQoUPq6ekp19sBgJpFzAAAat709LSGh4d148YNPXjwQD6f77Gw8fl81R7xCUNDQ7p586ZOnTol27aVcNK6E5/X2KyjVDYnSVpuR83Sh7Lf61FHwFZXc6OC9ge/P8dxdP78eUUiEQ0MDFT98AEAqBRiBgBglFgslt9jMz4+Lp/Pp97eXoXDYXV3d9dM2CSTSZ05c0Z7PntAnvaPatpJy9L/YuVZLP1+q+1TT2tAHQH/E4cKzM3N6dy5c4rH4zpy5Ig2b95cxncBALWNmAEAGGtqaiofNpFIRPX19dq+fbv6+vrU3d1d0f0q7+dksvrTnQeacQu7XWw5S1Gzqcmv/lAwfwvazMyMBgcHtbCwoKNHj6q9vb3ktQDAJMQMAGBVmJqayt+KthQ2vb296uvr07Zt2yoaNqPJBb0znlA25xb0TcyHsSR5PZZ2h4JqTC9ocHBQuVxOx44dU1tbWxlXAgAzEDMAgFVncnIyHzYTExOqr6/Xjh07FA6HVzxsbsVm9V40uWLXXzI1/Hc59+/q2LFjCgaDK74eANQiYgYAsKpFo9F82ESjUfn9/sfCxust/TawJZUKmSW9Qb/6Qq0VWw8Aag0xAwBYMyYmJvJ7bCYnJ2Xbdj5surq6lg2bbDar69evKxwOf+DhAqPJBf11LL6C0y/vUx3N2rKuoeLrAkAtIGYAAGuO67r5b2yGh4c1NTWVD5u+vj5t3bo1HzbXrl3TxYsX1dnZqcOHDy8bNE4mq0t3o8rkKv+RWuextG/rxoKfSwMAqwExAwBY01zX1cTERD5sYrGYGhoa8mFz9epVjYyMyLIsdXZ2amBg4LGgcV1XV+9Pa3wuVdbN/s/KkhQK+LW3o+WJY5sBYLUjZgAAeMR1XUUikfwem1gs9tjPlwua+0lHfxmbrsa4j9nT0aLN6+xqjwEAFUXMAACwDNd1deXKFV2+fPmJn4VCIR0/flx+v1+X/zOpmJMu6Nr3bv1Lb/z4R7o9fE3xyQn57QZt6d6uL544qede2FfwrJakFtunT39sQ8GvBQCTeao9AAAAtciyLI2Oji77s/HxcQ0NDSnhpAsOGUmKjo1qYW5Wn/nSV3XiW9/XV175uiTp9VeO69KFcwVfz5UUc9JKpAqfBQBMxjczAAA8xenTpzUzMyPbttXW1qYNGzaopaVFXq9Xu3bt0q3ZrP6dmC/LXplsNqtXv7xfi6mUzrz1dsGvtyR1BhvVH+KZMwDWjso9DhkAAMOcPHlSkmTby+9FGRuPlG3Tv9frVVuoQ7ev/7Oo17uSxmYd9YuYAbB2EDMAADzF0yJGengccyqbK+n6zvy8FlMLmk8m9bffX9K7b/9Bzx94sejrpbI5OZksxzQDWDOIGQAAihAvYq/M+/30h9/VpQuDkiSPx6M9n/u8Xv7OD0qeKxQgZgCsDcQMAABFSKQysqSSbjM7+NLL2rv/oKYnIvrzW0PK5bLKpIuPJOvRXKFACUMBgEE4AAAAgCJcj87oVmyurA/K/N6Jr2kuOaPX33izqAdgWpJ6Wpv08Y3ryzgVANQujmYGAKAIuRX4r8C9+7+gkff+obG7t4u+xkrMBQC1ipgBAKAInsK/OPlQiylHkjQ/myz6GisxFwDUKmIGAIAi+DzFf4Qmpiaf+LdMOq0//uaXqrdtbdm2vSpzAYBpOAAAAIAiBP11Re+X+clrr2phdlbhT+5Ra3tI8cmorgz9WvfvjOilb76mhqamoq7rPpoLANYK/uIBAFCEZttX9GufP/Cifvern+u3v/iZkvFpNTQF1NX3CR39xrf13Av7qzYXAJiG08wAACjSmyORkh+cWU5+r0cHu9urPQYAVAw31gIAUKSOgK1a2W9v6eE8ALCWEDMAABSpq7mxrM+ZKYUrqaulsdpjAEBFETMAABQpaPvUWgN7VCxJrbZPQX/1ZwGASiJmAAAoQU9roNojyK2ROQCg0ogZAABK0BHwa1OTv2p7ZyxJmwJ+dQT8VZoAAKqHmAEAoASWZak/FJTXU52c8Xos9bcHZVm1chQBAFQOMQMAQInsOq92h4JVWXt3KCi7zluVtQGg2ogZAADKYMu6Bu3cuL6ia+7cuF5b1jVUdE0AqCV11R4AAIDVoru1SZJ0LTqz4mvt/Mh6dbc0rfg6AFDLLNd1a+WIfAAAVoXR5ILeGU8om3PL+hwaSw/3yOwOBflGBgBEzAAAsCKcTFbvjif0YC4lSyopapZevyngV387e2QAYAkxAwDACnFdV2OzKd2KzSrmpAuOmqXfb7V96mkNqCPg59QyAPg/xAwAABWQcNK6E5/X2KyjVDYnScs+m2bpQ9nv9agjYKuruVFB21exOQHAJMQMAAAV5mSyijtpJVIZpXM55VzJY0k+j0dBf52abR+3kgHAMyBmAAAAABiJ58wAAAAAMBIxAwAAAMBIxAwAAAAAIxEzAAAAAIxEzAAAAAAwEjEDAAAAwEjEDAAAAAAjETMAAAAAjETMAAAAADASMQMAAADASMQMAAAAACMRMwAAAACMRMwAAAAAMBIxAwAAAMBIxAwAAAAAIxEzAAAAAIxEzAAAAAAwEjEDAAAAwEjEDAAAAAAjETMAAAAAjETMAAAAADASMQMAAADASMQMAAAAACMRMwAAAACMRMwAAAAAMBIxAwAAAMBIxAwAAAAAIxEzAAAAAIxEzAAAAAAwEjEDAAAAwEjEDAAAAAAjETMAAAAAjETMAAAAADASMQMAAADASMQMAAAAACMRMwAAAACMRMwAAAAAMBIxAwAAAMBIxAwAAAAAIxEzAAAAAIxEzAAAAAAw0n8B2mCBezUjfE0AAAAASUVORK5CYII=\n"
+          },
+          "metadata": {}
+        }
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/Drone Navigation Detection using Reinforcement Learning techniques/Model/README.md b/Drone Navigation Detection using Reinforcement Learning techniques/Model/README.md
new file mode 100644
index 000000000..8f6898fd0
--- /dev/null
+++ b/Drone Navigation Detection using Reinforcement Learning techniques/Model/README.md	
@@ -0,0 +1,111 @@
+# Drone Pathfinding and Navigation with Reinforcement Learning
+This project visualizes a drone's pathfinding journey in a grid environment, using both classical A* search and Reinforcement Learning (RL) techniques to achieve optimal navigation. The drone aims to reach a target location while avoiding obstacles and optimizing path cost. This file provides a comprehensive overview of the project’s structure, setup instructions, and available visualizations.
+
+# Table of Contents
+-> Features 
+-> Project Blocks 
+-> Setup Instructions 
+-> Usage 
+-> Visualizations
+
+    1. Basic Environment Setup
+    2. Static Path Visualization
+    3. Heatmap of Pathfinding Costs
+    4. Dynamic Movement Visualization
+    5. 3D Surface Plot of Pathfinding Costs
+-> Reinforcement Learning (RL) Model 
+-> Contributing 
+-> License
+
+# Features
+Pathfinding with A Algorithm*: Finds an optimal, shortest path from the starting position to the target using the A* heuristic. Reinforcement Learning Navigation: A reinforcement learning model trains to achieve the navigation goal while avoiding obstacles, rewarding efficient paths. Dynamic Obstacles: Specify obstacle positions to simulate real-world barriers and allow pathfinding adaptations. Comprehensive Visualizations: Includes static, dynamic, and 3D visualizations of the environment, path costs, and drone’s decision-making process. Real-time Animation: Watch the drone’s actions in a step-by-step movement toward the target.
+
+# Project Structure
+pathfinding block: Contains the A* algorithm and helper functions for calculating paths.
+reinforcement_learning block: Implements the reinforcement learning environment using OpenAI Gym, where the drone learns an optimal policy for navigation.
+visualizations block: Defines visualization functions, including static, dynamic, and heatmap visualizations.
+
+# Setup Instructions
+Clone the repository:
+
+git clone https://github.com/Panchadip-128/Drone-Navigation_Detection_using_RL.git cd Drone-Navigation_Detection_using_RL
+
+# Install required dependencies:
+    pip install -r requirements.txt
+
+Run the script: Drone-Navigation_Detection_using_RL.ipynb
+
+# Usage:
+Specify Start, Target, and Obstacle Positions: Set coordinates for the drone’s starting position, the target, and obstacles. Choose Navigation Algorithm: Run either the A* pathfinding method or the reinforcement learning model to observe different navigation approaches.
+
+Select Visualization Type: View different visualizations of the environment, path, costs, and drone movements.
+
+# Visualizations
+The project includes several visualizations to illustrate pathfinding and navigation strategies in the environment.
+
+- Basic Environment Setup Sets up a grid environment, marking the drone’s starting position, the target, and obstacles.
+
+      def visualize_environment(drone_pos, target_pos, obstacles, grid_size=(10, 10))
+
+  ![env graph](https://github.com/user-attachments/assets/a6868ac3-d936-4b03-a72d-1d20801c6aac)
+
+
+- Static Path Visualization Displays a static view of the calculated A* path from start to target.
+
+      def visualize_path(drone_pos, target_pos, obstacles, path)
+  
+  ![a star graph](https://github.com/user-attachments/assets/d70ec385-9cc2-40d6-adf6-5b22f12723d9)
+
+- Heatmap of Pathfinding Costs Shows a heatmap for traversal costs to each grid cell, providing insight into pathfinding challenges.
+
+      def visualize_cost_heatmap(start, goal, obstacles, grid_width, grid_height)
+
+  ![pathfinding_heat-map](https://github.com/user-attachments/assets/320baa43-f83b-4567-8d99-131bfb4dd3b7)
+
+- Dynamic Movement Visualization Animates the drone’s movement toward the target, step-by-step, showing real-time path adjustments.
+
+  ![Navigation Graph](https://github.com/user-attachments/assets/acc92014-bbff-40de-b964-dc649d00a2d7)
+
+
+
+- 3D Surface Plot of Pathfinding Costs Visualizes the cost distribution across the grid in 3D, highlighting areas with high or low pathfinding costs.
+  
+  ![3D Path Finding Cost Suraface schematic](https://github.com/user-attachments/assets/f243d58c-1948-462a-a50b-cfd763807bf9)
+
+- Navigation Graph:
+
+![Drone Navigation Graph](https://github.com/user-attachments/assets/bc69c957-acac-48ce-ad2d-cef3399f3c39)
+
+
+Reinforcement Learning (RL) Model Overview In addition to the A* algorithm, this project includes a reinforcement learning approach to allow the drone to learn optimal navigation strategies through interaction with the environment. The RL agent is implemented using OpenAI Gym and trained with the Proximal Policy Optimization (PPO) algorithm from stable-baselines3.
+
+RL Environment The RL environment for the drone is defined in DroneEnv, an OpenAI Gym environment that:
+
+Defines the drone’s possible actions: Up, Down, Left, Right, and diagonal moves. Contains a custom reward function: Positive Reward: Awarded for reaching the target. Penalty: Applied when the drone hits an obstacle or moves away from the target. Exploration vs. Exploitation: Introduces a small exploration rate (epsilon) to encourage the drone to explore initially before converging on optimal paths.
+
+# Training the RL Model
+    from stable_baselines3 import PPO
+    
+    env = DroneEnv()
+    model = PPO("MlpPolicy", env, verbose=1)
+    model.learn(total_timesteps=10000)  # Training the model with adjustable timesteps
+    
+# Evaluation
+After training, the RL model navigates the drone autonomously, continuously adjusting its path based on learned policies. This approach enhances the drone’s flexibility, enabling it to adapt even with changing obstacles or targets.
+
+# Visualizing RL Navigation
+The RL model’s path can be dynamically visualized, showing how it navigates step-by-step toward the target:
+
+    obs = env.reset()
+    for _ in range(20):
+        action, _states = model.predict(obs)
+        obs, rewards, done, info = env.step(action)
+        env.render()
+        if done:
+            obs = env.reset()
+            
+# Contributing
+Contributions are welcome! Please fork the repository and create a pull request with improvements or feature addition or contact @Github:Panchadip-128 or @mail: panchadip125@gmail.com.
+
+# License
+This project is licensed under MIT License policies.
diff --git a/Drone Navigation Detection using Reinforcement Learning techniques/requirements.txt b/Drone Navigation Detection using Reinforcement Learning techniques/requirements.txt
new file mode 100644
index 000000000..79b2d24e0
--- /dev/null
+++ b/Drone Navigation Detection using Reinforcement Learning techniques/requirements.txt	
@@ -0,0 +1,7 @@
+numpy==1.24.0
+matplotlib==3.7.1
+seaborn==0.12.2
+scikit-learn==1.2.2
+pandas==2.0.3
+gym==0.21.0
+stable-baselines3==1.8.2