diff --git a/awpy/analytics/map_control.py b/awpy/analytics/map_control.py
new file mode 100644
index 000000000..d9727c9b1
--- /dev/null
+++ b/awpy/analytics/map_control.py
@@ -0,0 +1,424 @@
+"""Functions for calculating map control values and metrics.
+
+    A team's map control can be thought of as the sum of it's
+    individual player's control.
+
+    Example notebook:
+
+    # pylint: disable=line-too-long
+    github.com/pnxenopoulos/awpy/blob/main/examples/05_Map_Control_Calculations_And_Visualizations.ipynb
+"""
+
+from collections import defaultdict, deque
+
+import numpy as np
+
+from awpy.analytics.nav import (
+    area_distance,
+    calculate_map_area,
+    calculate_tile_area,
+    find_closest_area,
+)
+from awpy.data import NAV, NAV_GRAPHS
+from awpy.types import (
+    BFSTileData,
+    FrameMapControlValues,
+    FrameTeamMetadata,
+    GameFrame,
+    GameRound,
+    PlayerPosition,
+    TeamFrameInfo,
+    TeamMapControlValues,
+    TeamMetadata,
+    TileDistanceObject,
+    TileId,
+    TileNeighbors,
+)
+
+
+def _approximate_neighbors(
+    map_name: str,
+    source_tile_id: TileId,
+    n_neighbors: int = 5,
+) -> list[TileDistanceObject]:
+    """Approximates neighbors for isolated tiles by finding n closest tiles.
+
+    Args:
+        map_name (str): Map for source_tile_id
+        source_tile_id (TileId): TileId for source tile
+        n_neighbors (int): Number of closest tiles/approximated neighbors wanted
+
+    Returns:
+        List of TileDistanceObjects for n closest tiles
+
+    Raises:
+        ValueError: If source_tile_id is not in awpy.data.NAV[map_name]
+                    If n_neighbors <= 0
+    """
+    if source_tile_id not in NAV[map_name]:
+        msg = "Tile ID not found."
+        raise ValueError(msg)
+    if n_neighbors <= 0:
+        msg = "Invalid n_neighbors value. Must be > 0."
+        raise ValueError(msg)
+
+    current_map_info = NAV[map_name]
+    possible_neighbors_arr: list[TileDistanceObject] = []
+
+    for tile in current_map_info:
+        if tile != source_tile_id:
+            current_tile_distance_obj = TileDistanceObject(
+                tile_id=tile,
+                distance=area_distance(
+                    map_name, tile, source_tile_id, dist_type="euclidean"
+                )["distance"],
+            )
+
+            possible_neighbors_arr.append(current_tile_distance_obj)
+
+    return sorted(possible_neighbors_arr, key=lambda d: d.distance)[:n_neighbors]
+
+
+def _bfs(
+    map_name: str,
+    current_tiles: list[TileId],
+    neighbor_info: TileNeighbors,
+    area_threshold: float = 1 / 20,
+) -> TeamMapControlValues:
+    """Helper function to run bfs from given tiles to generate map_control values dict.
+
+    Values are allocated to tiles depending on how many tiles are between it
+    and the source tile (aka tile distance). The smaller the tile distance,
+    the close the tile's value is to 1. Tiles are considered until the cumulative
+    tile area reaches the current map's navigable area * area_threshold, which is
+    1/20 as a default. This means the BFS search will stop once the cumulative tile
+    area reaches this threshold.
+
+    Args:
+        map_name (str): Map for current_tiles
+        current_tiles (TileId): List of source tiles for bfs iteration(s)
+        neighbor_info (dict): Dictionary mapping tile to its navigable neighbors
+        area_threshold (float): Percentage representing amount of map's total
+                                navigable area which is the max cumulative tile
+                                area for each bfs algorithm
+
+    Returns:
+        TeamMapControlValues containing map control values
+
+    Raises:
+        ValueError: If area_threshold <= 0
+    """
+    if area_threshold <= 0:
+        msg = "Invalid area_threshold value. Must be > 0."
+        raise ValueError(msg)
+
+    total_map_area = calculate_map_area(map_name)
+
+    map_control_values: TeamMapControlValues = defaultdict(list)
+    for cur_start_tile in current_tiles:
+        tiles_seen: set[TileId] = set()
+
+        start_tile = BFSTileData(
+            tile_id=cur_start_tile, map_control_value=1.0, steps_left=10
+        )
+
+        queue: deque[BFSTileData] = deque([start_tile])
+
+        current_player_area = 0
+
+        while queue and current_player_area < total_map_area * area_threshold:
+            cur_tile = queue.popleft()
+            cur_id = cur_tile.tile_id
+            if cur_id not in tiles_seen:
+                tiles_seen.add(cur_id)
+                map_control_values[cur_id].append(cur_tile.map_control_value)
+
+                neighbors = list(neighbor_info[cur_id])
+                if len(neighbors) == 0:
+                    neighbors = [
+                        tile.tile_id
+                        for tile in _approximate_neighbors(map_name, cur_id)
+                    ]
+
+                queue.extend(
+                    [
+                        BFSTileData(
+                            tile_id=neighbor,
+                            map_control_value=max((cur_tile.steps_left - 1) / 10, 0.1),
+                            steps_left=cur_tile.steps_left - 1,
+                        )
+                        for neighbor in neighbors
+                    ]
+                )
+
+                cur_tile_area = calculate_tile_area(map_name, cur_id)
+                current_player_area += cur_tile_area
+
+    return map_control_values
+
+
+def _calc_frame_map_control_tile_values(
+    map_name: str,
+    ct_tiles: list[TileId],
+    t_tiles: list[TileId],
+    neighbor_info: TileNeighbors,
+) -> FrameMapControlValues:
+    """Calculate a frame's map control values for each side.
+
+    Values are allocated to tiles depending on how many tiles are between it
+    and the source tile (aka tile distance). The smaller the tile distance,
+    the close the tile's value is to 1. Tiles are considered until a player's
+    tiles' total area reach the area_threshold. The area threshold is a float
+    between 0 and 1, representing the percentage of the current map's total area.
+
+    Args:
+        map_name (str): Map for other arguments
+        ct_tiles (list): List of CT-occupied tiles
+        t_tiles (list): List of T-occupied tiles
+        neighbor_info (TileNeighbors): Object with tile to neighbor mapping
+
+    Returns:
+        FrameMapControlValues object containing each team's map control values
+    """
+    return FrameMapControlValues(
+        t_values=_bfs(map_name, t_tiles, neighbor_info),
+        ct_values=_bfs(map_name, ct_tiles, neighbor_info),
+    )
+
+
+def graph_to_tile_neighbors(
+    neighbor_pairs: list[tuple[TileId, TileId]],
+) -> TileNeighbors:
+    """Convert list of neighboring tiles to TileNeighbors object.
+
+    Args:
+        neighbor_pairs (list): List of tuples (pairs of TileId)
+
+    Returns: TileNeighbors object with tile to neighbor mapping
+    """
+    tile_to_neighbors: TileNeighbors = defaultdict(set)
+
+    for tile_1, tile_2 in neighbor_pairs:
+        tile_to_neighbors[tile_1].add(tile_2)
+        tile_to_neighbors[tile_2].add(tile_1)
+
+    return tile_to_neighbors
+
+
+def calc_parsed_frame_map_control_values(
+    map_name: str,
+    current_player_data: FrameTeamMetadata,
+) -> FrameMapControlValues:
+    """Calculate tile map control values for each team given parsed frame.
+
+    Values are allocated to tiles depending on how many tiles are between it
+    and the source tile (aka tile distance). The smaller the tile distance,
+    the close the tile's value is to 1. Tiles are considered until a player's
+    tiles' total area reach the area_threshold. The area threshold is a float
+    between 0 and 1, representing the percentage of the current map's total area.
+
+    Args:
+        map_name (str): Map used for find_closest_area and
+            relevant tile neighbor dictionary
+        current_player_data (FrameTeamMetadata): Object containing team metadata
+            (player positions, etc.). Expects extract_team_metadata output format
+
+    Returns: FrameMapControlValues object containing each team's map control values
+
+    Raises:
+        ValueError: If map_name is not in awpy.data.NAV
+    """
+    if map_name not in NAV:
+        msg = "Map not found."
+        raise ValueError(msg)
+
+    neighbors_dict = graph_to_tile_neighbors(list(NAV_GRAPHS[map_name].edges))
+
+    t_tiles = [
+        find_closest_area(map_name, i)["areaId"]
+        for i in current_player_data.t_metadata.alive_player_locations
+    ]
+    ct_tiles = [
+        find_closest_area(map_name, i)["areaId"]
+        for i in current_player_data.ct_metadata.alive_player_locations
+    ]
+
+    return _calc_frame_map_control_tile_values(
+        map_name, ct_tiles, t_tiles, neighbors_dict
+    )
+
+
+def calc_frame_map_control_values(
+    map_name: str,
+    frame: GameFrame,
+) -> FrameMapControlValues:
+    """Calculate tile map control values for each team given awpy frame object.
+
+    Values are allocated to tiles depending on how many tiles are between it
+    and the source tile (aka tile distance). The smaller the tile distance,
+    the close the tile's value is to 1. Tiles are considered until a player's
+    tiles' total area reach the area_threshold. The area threshold is a float
+    between 0 and 1, representing the percentage of the current map's total area.
+
+    Args:
+        map_name (str): Map used for find_closest_area and
+            relevant tile neighbor dictionary
+        frame (GameFrame): Awpy frame object for map control calculations
+
+    Returns: FrameMapControlValues object containing each team's map control values
+
+    Raises:
+        ValueError: If map_name is not in awpy.data.NAV
+    """
+    if map_name not in NAV:
+        msg = "Map not found."
+        raise ValueError(msg)
+
+    return calc_parsed_frame_map_control_values(
+        map_name=map_name,
+        current_player_data=extract_teams_metadata(frame),
+    )
+
+
+def _extract_team_metadata(
+    side_data: TeamFrameInfo,
+) -> TeamMetadata:
+    """Helper function to parse player locations in given side_data.
+
+    Args:
+        side_data (TeamFrameInfo): Object with metadata for side's players.
+
+    Returns: TeamMetadata with metadata on team's players
+    """
+    coords = ("x", "y", "z")
+    alive_players: list[PlayerPosition] = [
+        [player[dim] for dim in coords]
+        for player in side_data["players"] or []
+        if player["isAlive"]
+    ]
+
+    return TeamMetadata(alive_player_locations=alive_players)
+
+
+def extract_teams_metadata(
+    frame: GameFrame,
+) -> FrameTeamMetadata:
+    """Parse frame data for alive player locations for both sides.
+
+    Args:
+        frame (GameFrame): Dictionary in the form of an awpy frame
+            containing relevant data for both sides
+
+    Returns: FrameTeamMetadata containing team metadata (player
+        positions, etc.)
+    """
+    return FrameTeamMetadata(
+        t_metadata=_extract_team_metadata(frame["t"]),
+        ct_metadata=_extract_team_metadata(frame["ct"]),
+    )
+
+
+def _calc_map_control_metric_from_dict(
+    map_name: str,
+    mc_values: FrameMapControlValues,
+) -> float:
+    """Return map control metric given FrameMapControlValues object.
+
+    Map Control metric is used to quantify how much of the map is controlled
+    by T/CT. Each tile is given a value between -1 (complete T control) and 1
+    (complete CT control). If a tile is controlled by both teams, a value is
+    found by taking the ratio between the sum of CT values and sum of CT and
+    T values. Once all of the tiles' values are calculated, a weighted sum
+    is done on the tiles' values where the tiles' area is the weights.
+    This weighted sum is transformed to fit the range [-1, 1] and then
+    returned as the map control metric.
+
+    Args:
+        map_name (str): Map used in calculate_tile_area
+        mc_values (FrameMapControlValues): Object containing map control
+            values for both teams.
+            Expected format that of calc_frame_map_control_values output
+
+    Returns: Map Control Metric
+    """
+    current_map_control_value: list[float] = []
+    tile_areas: list[float] = []
+    for tile in set(mc_values.ct_values) | set(mc_values.t_values):
+        ct_val, t_val = mc_values.ct_values[tile], mc_values.t_values[tile]
+
+        current_map_control_value.append(sum(ct_val) / (sum(ct_val) + sum(t_val)))
+        tile_areas.append(calculate_tile_area(map_name, int(tile)))
+
+    np_current_map_control_value = np.array(current_map_control_value)
+    np_tile_areas = np.array(tile_areas)
+
+    return (
+        (sum(np_current_map_control_value * np_tile_areas) / sum(np_tile_areas)) * 2
+    ) - 1
+
+
+def calc_frame_map_control_metric(
+    map_name: str,
+    frame: GameFrame,
+) -> float:
+    """Return map control metric for given awpy frame.
+
+    Map Control metric is used to quantify how much of the map is controlled
+    by T/CT. Each tile is given a value between -1 (complete T control) and 1
+    (complete CT control). If a tile is controlled by both teams, a value is
+    found by taking the ratio between the sum of CT values and sum of CT and
+    T values. Once all of the tiles' values are calculated, a weighted sum
+    is done on the tiles' values where the tiles' area is the weights.
+    This weighted sum is transformed to fit the range [-1, 1] and then
+    returned as the map control metric.
+
+    Args:
+        map_name (str): Map used position_transform call
+        frame (GameFrame): awpy frame to calculate map control metric for
+
+    Returns: Map Control metric for given frame
+
+    Raises:
+        ValueError: If map_name is not in awpy.data.NAV
+    """
+    if map_name not in NAV:
+        msg = "Map not found."
+        raise ValueError(msg)
+
+    map_control_values = calc_frame_map_control_values(map_name, frame)
+
+    return _calc_map_control_metric_from_dict(map_name, map_control_values)
+
+
+def calculate_round_map_control_metrics(
+    map_name: str,
+    round_data: GameRound,
+) -> list[float]:
+    """Return list of map control metric for given awpy round.
+
+    Map Control metric is used to quantify how much of the map is controlled
+    by T/CT. Each tile is given a value between 0 (complete T control) and 1
+    (complete CT control). If a tile is controlled by both teams, a value is
+    found by taking the ratio between the sum of CT values and sum of CT and
+    T values. Once all of the tiles' values are calculated, a weighted sum
+    is done on the tiles' values where the tiles' area is the weights.
+    This weighted sum is the map control metric returned at the end of the function.
+
+    Args:
+        map_name (str): Map used position_transform call
+        round_data (GameRound): awpy round to calculate map control metrics for
+
+    Returns: List of map control metric values for given round
+
+    Raises:
+        ValueError: If map_name is not in awpy.data.NAV
+    """
+    if map_name not in NAV:
+        msg = "Map not found."
+        raise ValueError(msg)
+
+    map_control_metrics: list[float] = []
+    for frame in round_data["frames"] or []:
+        current_frame_metric = calc_frame_map_control_metric(map_name, frame)
+        map_control_metrics.append(current_frame_metric)
+    return map_control_metrics
diff --git a/awpy/analytics/nav.py b/awpy/analytics/nav.py
index 014758526..9dde5cd1a 100644
--- a/awpy/analytics/nav.py
+++ b/awpy/analytics/nav.py
@@ -56,6 +56,7 @@
     DistanceType,
     GameFrame,
     PlaceMatrix,
+    TileId,
     Token,
 )
 
@@ -1600,3 +1601,60 @@ def token_distance(
         distance_type,
         reference_point,
     )
+
+
+def calculate_tile_area(
+    map_name: str,
+    tile_id: TileId,
+) -> float:
+    """Calculates area of a given tile in a given map.
+
+    Args:
+        map_name (string): Map for tile
+        tile_id (TileId): Id for tile
+
+    Returns:
+        A float representing the area of the tile
+
+    Raises:
+        ValueError: If map_name is not in awpy.data.NAV
+                    If area_id is not in awpy.data.NAV[map_name]
+    """
+    if map_name not in NAV:
+        msg = "Map not found."
+        raise ValueError(msg)
+    if tile_id not in NAV[map_name]:
+        msg = "Tile ID not found."
+        raise ValueError(msg)
+
+    tile_info = NAV[map_name][tile_id]
+
+    tile_width = tile_info["northWestX"] - tile_info["southEastX"]
+    tile_height = tile_info["northWestY"] - tile_info["southEastY"]
+
+    return tile_width * tile_height
+
+
+def calculate_map_area(
+    map_name: str,
+) -> float:
+    """Calculates total area of all nav tiles in a given map.
+
+    Args:
+        map_name (string): Map for area calculations
+
+    Returns:
+        A float representing the area of the map
+
+    Raises:
+        ValueError: If map_name is not in awpy.data.NAV
+    """
+    if map_name not in NAV:
+        msg = "Map not found."
+        raise ValueError(msg)
+
+    total_area = 0
+    for tile in NAV[map_name]:
+        total_area += calculate_tile_area(map_name, tile)
+
+    return total_area
diff --git a/awpy/types.py b/awpy/types.py
index 11e91c788..bbc33c21e 100644
--- a/awpy/types.py
+++ b/awpy/types.py
@@ -1,7 +1,7 @@
 """This module contains the type definitions for the parsed json structure."""
 
 from dataclasses import dataclass
-from typing import Literal, NotRequired, TypeGuard, final, overload
+from typing import Literal, NotRequired, TypeAlias, TypeGuard, final, overload
 
 from typing_extensions import TypedDict
 
@@ -702,6 +702,85 @@ class RoundStatistics(TypedDict):
     players_killed: dict[Literal["CT", "T"], set[str]]
 
 
+# Type to represent different options for map control minimap plot
+MapControlPlotType = Literal["default", "players"]
+
+# Type to represent tile id for navigation tiles.
+TileId: TypeAlias = int
+
+# Type to represent player position (list of floats [x, y, z])
+PlayerPosition: TypeAlias = list[float]
+
+# Return type for awpy.analytics.map_control._bfs_helper.
+# Contains map control values for one team.
+# Maps TileId to list of tile map control values.
+TeamMapControlValues: TypeAlias = dict[TileId, list[float]]
+
+# Return type for awpy.analytics.map_control.graph_to_tile_neighbors
+# Maps TileId to set of neighboring tiles.
+TileNeighbors: TypeAlias = dict[TileId, set[int]]
+
+
+@dataclass
+class TileDistanceObject:
+    """Dataclass with data for map control tile distance calculations.
+
+    Holds information for distance to source tile and tile_id
+    distance is associated with.
+    """
+
+    tile_id: TileId
+    distance: float
+
+
+@dataclass
+class BFSTileData:
+    """Dataclass containing data for tiles during bfs algorithm.
+
+    Holds information for tile_id for tile, current map control
+    value, and steps remaining for bfs algorithm
+    """
+
+    tile_id: TileId
+    map_control_value: float
+    steps_left: int
+
+
+@dataclass
+class TeamMetadata:
+    """Dataclass containing metadata for one team.
+
+    Holds information for aliver player locations. Can include
+    more metadata (utility, bomb location, etc.) in the future
+    """
+
+    alive_player_locations: list[PlayerPosition]
+
+
+@dataclass
+class FrameTeamMetadata:
+    """Dataclass with metadata on both teams in frame.
+
+    Return type for awpy.analytics.map_control.extract_teams_metadata.
+    Holds parsed metadata object (TeamMetadata) for both teams
+    """
+
+    t_metadata: TeamMetadata
+    ct_metadata: TeamMetadata
+
+
+@dataclass
+class FrameMapControlValues:
+    """Dataclass with map control values for both teams in frame.
+
+    Return type for awpy.analytics.map_control.calc_map_control.
+    Holds TeamMapControlValues for each team for a certain frame.
+    """
+
+    t_values: TeamMapControlValues
+    ct_values: TeamMapControlValues
+
+
 @overload
 def other_side(side: Literal["CT"]) -> Literal["T"]:
     ...
diff --git a/awpy/visualization/__init__.py b/awpy/visualization/__init__.py
index bcdf02d25..e2810f2ea 100644
--- a/awpy/visualization/__init__.py
+++ b/awpy/visualization/__init__.py
@@ -1,2 +1,3 @@
 """Provides data visualization capabilities for CSGO data."""
 SIDE_COLORS = {"ct": "#5d79ae", "t": "#de9b35"}
+AWPY_TMP_FOLDER = "csgo_tmp"
diff --git a/awpy/visualization/plot.py b/awpy/visualization/plot.py
index fda0864d5..b18f84c55 100644
--- a/awpy/visualization/plot.py
+++ b/awpy/visualization/plot.py
@@ -14,19 +14,37 @@
 
 https://github.com/pnxenopoulos/awpy/blob/main/examples/02_Basic_CSGO_Visualization.ipynb
 """
+import logging
 import os
 import shutil
-from typing import Literal
+from typing import Literal, get_args
 
 import imageio.v3 as imageio
 import matplotlib.pyplot as plt
 import numpy as np
+from matplotlib import patches
 from matplotlib.axes import Axes
 from matplotlib.figure import Figure
 from tqdm import tqdm
 
-from awpy.data import MAP_DATA
-from awpy.types import BombInfo, GameFrame, GameRound, PlayerInfo, PlotPosition
+from awpy.analytics.map_control import (
+    calc_parsed_frame_map_control_values,
+    extract_teams_metadata,
+)
+from awpy.data import MAP_DATA, NAV
+from awpy.types import (
+    BombInfo,
+    FrameMapControlValues,
+    FrameTeamMetadata,
+    GameFrame,
+    GameRound,
+    MapControlPlotType,
+    PlayerInfo,
+    PlotPosition,
+    TeamMetadata,
+    lower_side,
+)
+from awpy.visualization import AWPY_TMP_FOLDER, SIDE_COLORS
 
 
 def plot_map(
@@ -35,8 +53,8 @@ def plot_map(
     """Plots a blank map.
 
     Args:
-        map_name (string, optional): Map to search. Defaults to "de_dust2"
-        map_type (string, optional): "original" or "simpleradar". Defaults to "original"
+        map_name (str, optional): Map to search. Defaults to "de_dust2"
+        map_type (str, optional): "original" or "simpleradar". Defaults to "original"
         dark (bool, optional): Only for use with map_type="simpleradar".
             Indicates if you want to use the SimpleRadar dark map type
             Defaults to False
@@ -74,9 +92,9 @@ def position_transform(
     """Transforms an X or Y coordinate.
 
     Args:
-        map_name (string): Map to search
+        map_name (str): Map to search
         position (float): X or Y coordinate
-        axis (string): Either "x" or "y" (lowercase)
+        axis (str): Either "x" or "y" (lowercase)
 
     Returns:
         float
@@ -106,7 +124,7 @@ def position_transform_all(
     """Transforms an X or Y coordinate.
 
     Args:
-        map_name (string): Map to search
+        map_name (str): Map to search
         position (tuple): (X,Y,Z) coordinates
 
     Returns:
@@ -143,8 +161,8 @@ def plot_positions(
             marker (str): Marker for the position
             alpha (float): Alpha value for the position
             sizes (float): Size for the position
-        map_name (string, optional): Map to search. Defaults to "de_ancient"
-        map_type (string, optional): "original" or "simpleradar". Defaults to "original"
+        map_name (str, optional): Map to search. Defaults to "de_ancient"
+        map_type (str, optional): "original" or "simpleradar". Defaults to "original"
         dark (bool, optional): Only for use with map_type="simpleradar".
             Indicates if you want to use the SimpleRadar dark map type
             Defaults to False
@@ -233,10 +251,10 @@ def plot_round(
     Only use untransformed coordinates.
 
     Args:
-        filename (string): Filename to save the gif
+        filename (str): Filename to save the gif
         frames (list): List of frames from a parsed demo
-        map_name (string, optional): Map to search. Defaults to "de_ancient"
-        map_type (string, optional): "original" or "simpleradar". Defaults to "original
+        map_name (str, optional): Map to search. Defaults to "de_ancient"
+        map_type (str, optional): "original" or "simpleradar". Defaults to "original
         dark (bool, optional): Only for use with map_type="simpleradar".
             Indicates if you want to use the SimpleRadar dark map type
             Defaults to False
@@ -246,9 +264,9 @@ def plot_round(
     Returns:
         True, saves .gif
     """
-    if os.path.isdir("csgo_tmp"):
-        shutil.rmtree("csgo_tmp/")
-    os.mkdir("csgo_tmp")
+    if os.path.isdir(AWPY_TMP_FOLDER):
+        shutil.rmtree(f"{AWPY_TMP_FOLDER}/")
+    os.mkdir(AWPY_TMP_FOLDER)
     image_files: list[str] = []
     for i, game_frame in tqdm(enumerate(frames)):
         positions = [_get_plot_position_for_bomb(game_frame["bomb"], map_name)]
@@ -264,12 +282,12 @@ def plot_round(
             map_type=map_type,
             dark=dark,
         )
-        image_files.append(f"csgo_tmp/{i}.png")
+        image_files.append(f"{AWPY_TMP_FOLDER}/{i}.png")
         figure.savefig(image_files[-1], dpi=300, bbox_inches="tight")
         plt.close()
     images = [imageio.imread(file) for file in image_files]
     imageio.imwrite(filename, images, duration=1000 / fps)
-    shutil.rmtree("csgo_tmp/")
+    shutil.rmtree(f"{AWPY_TMP_FOLDER}/")
     return True
 
 
@@ -288,10 +306,10 @@ def plot_nades(
         rounds (list): List of round objects from a parsed demo
         nades (list, optional): List of grenade types to plot
             Defaults to []
-        side (string, optional): Specify side to plot grenades. Either "CT" or "T".
+        side (str, optional): Specify side to plot grenades. Either "CT" or "T".
             Defaults to "CT"
-        map_name (string, optional): Map to search. Defaults to "de_ancient"
-        map_type (string, optional): "original" or "simpleradar". Defaults to "original"
+        map_name (str, optional): Map to search. Defaults to "de_ancient"
+        map_type (str, optional): "original" or "simpleradar". Defaults to "original"
         dark (bool, optional): Only for use with map_type="simpleradar".
             Indicates if you want to use the SimpleRadar dark map type.
             Defaults to False
@@ -301,6 +319,7 @@ def plot_nades(
     """
     if nades is None:
         nades = []
+
     figure, axes = plot_map(map_name=map_name, map_type=map_type, dark=dark)
     for game_round in rounds:
         if game_round["grenades"] is None:
@@ -326,3 +345,272 @@ def plot_nades(
     axes.get_xaxis().set_visible(b=False)
     axes.get_yaxis().set_visible(b=False)
     return figure, axes
+
+
+def _plot_frame_team_player_positions(
+    map_name: str,
+    side: Literal["CT", "T"],
+    player_data: TeamMetadata,
+    axes: plt.Axes,
+) -> None:
+    """Helper function to team's alive player positions.
+
+    Args:
+        map_name (str): Map used position_transform call
+        side (Literal): Side used to determine player scatterplot color
+        player_data (TeamMetadata): Team's metadata dictionary. Expected format same as
+            output of extract_player_positions
+        axes (plt.axes): axes object for plotting
+
+    Returns: Nothing, all plotting is done on ax object
+    """
+    transformed_x = [
+        position_transform(map_name, loc[0], "x")
+        for loc in player_data.alive_player_locations
+    ]
+    transformed_y = [
+        position_transform(map_name, loc[1], "y")
+        for loc in player_data.alive_player_locations
+    ]
+    side_color = SIDE_COLORS[lower_side(side)]
+    color_arr = [side_color] * len(player_data.alive_player_locations)
+    axes.scatter(transformed_x, transformed_y, c=color_arr)
+
+
+def _plot_map_control_from_dict(
+    map_name: str,
+    occupied_tiles: FrameMapControlValues,
+    axes: plt.Axes,
+    player_data: FrameTeamMetadata | None = None,
+) -> None:
+    """Helper function to plot map control nav tile plot.
+
+    Args:
+        map_name (str): Map used position_transform call
+        occupied_tiles (TeamMapControlValues): Map control values for occupied tiles
+        axes (plt.axes): axes object for plotting
+        player_data (FrameTeamMetadata): Dictionary of player positions
+            for each team. Expected format same as output of extract_player_positions
+
+    Returns: Nothing, all plotting is done on ax object
+    """
+    ct_tiles, t_tiles = occupied_tiles.ct_values, occupied_tiles.t_values
+
+    # Iterate through the tiles that have a value
+    for tile in set(ct_tiles.keys()).union(set(t_tiles.keys())):
+        if tile in NAV[map_name]:
+            area = NAV[map_name][tile]
+
+            width = position_transform(
+                map_name, area["southEastX"], "x"
+            ) - position_transform(map_name, area["northWestX"], "x")
+            height = position_transform(
+                map_name, area["northWestY"], "y"
+            ) - position_transform(map_name, area["southEastY"], "y")
+
+            # Use max value (default value 0 if no values exist)
+            # for each side for the current tile
+            ct_val = max(ct_tiles[tile], default=0)
+            t_val = max(t_tiles[tile], default=0)
+
+            # Map T/CT Val to RGB Color.
+            # If CT Val is non-zero and T Val is 0, color will be Green
+            # If T Val is non-zero and CT Val is 0, color will be Red
+            # If T and CT Val are non-zero, color is weighted average
+            # between Green and Red.
+            cur_color = ct_val * np.array([0, 1, 0]) + t_val * np.array([1, 0, 0])
+
+            rect = patches.Rectangle(
+                (
+                    position_transform(map_name, area["northWestX"], "x"),
+                    position_transform(map_name, area["southEastY"], "y"),
+                ),
+                width,
+                height,
+                linewidth=1,
+                edgecolor=cur_color,
+                facecolor=cur_color,
+                alpha=1.0,
+            )
+            axes.add_patch(rect)
+        else:
+            logging.info("Tile not found in map: %s", tile)
+
+    # Plot player positions if given
+    if player_data is not None:
+        _plot_frame_team_player_positions(map_name, "CT", player_data.ct_metadata, axes)
+        _plot_frame_team_player_positions(map_name, "T", player_data.t_metadata, axes)
+
+    axes.axis("off")
+
+
+def plot_frame_map_control(
+    map_name: str,
+    frame: GameFrame,
+    plot_type: MapControlPlotType = "default",
+    given_fig_ax: tuple[plt.Figure, plt.Axes] | tuple[None, None] = (None, None),
+) -> tuple[Figure, Axes]:
+    """Visualize map control for awpy frame.
+
+    Args:
+        map_name (str): Map used position_transform call
+        frame (GameFrame): awpy frame to calculate map control for
+        plot_type (MapControlPlotType): Determines which type of plot is created
+            (either default or with players)
+        given_fig_ax: Optional tuple containing figure and ax objects for plotting
+
+    Returns: Nothing, all plotting is done on ax object
+
+    Raises:
+        ValueError: If map_name is not in awpy.data.NAV
+    """
+    if map_name not in NAV:
+        msg = "Map not found."
+        raise ValueError(msg)
+    if plot_type not in get_args(MapControlPlotType):
+        msg = "dist_type can only be default or players"
+        raise ValueError(msg)
+    if given_fig_ax[0] is None:
+        given_fig_ax = plot_map(map_name=map_name, map_type="simpleradar", dark=True)
+
+    figure, axes = given_fig_ax
+    player_positions = extract_teams_metadata(frame)
+    map_control_dict = calc_parsed_frame_map_control_values(map_name, player_positions)
+    if plot_type == "players":
+        _plot_map_control_from_dict(
+            map_name,
+            map_control_dict,
+            axes,
+            player_data=player_positions,
+        )
+    else:  # default
+        _plot_map_control_from_dict(
+            map_name,
+            map_control_dict,
+            axes,
+        )
+
+    return figure, axes
+
+
+def plot_round_map_control(
+    filename: str,
+    map_name: str,
+    round_data: GameRound,
+    plot_type: MapControlPlotType = "default",
+) -> Literal[True]:
+    """Create gif summarizing map control for round.
+
+    Args:
+        filename (str): Filepath to save the gif to file
+        map_name (str): Map used in plot_frame_map_control call
+        round_data (GameRound): Round whose map control will be animated.
+            Expected format that of awpy round
+        plot_type (MapControlPlotType): Determines which type of plot is created
+            (either with or without players)
+
+    Returns: True, ensuring function has completed
+
+    Raises:
+        ValueError: If map_name is not in awpy.data.NAV
+    ]
+    """
+    if map_name not in NAV:
+        msg = "Map not found."
+        raise ValueError(msg)
+
+    if os.path.isdir(AWPY_TMP_FOLDER):
+        shutil.rmtree(f"{AWPY_TMP_FOLDER}/")
+    os.mkdir(AWPY_TMP_FOLDER)
+
+    images: list[np.ndarray] = []
+    print("Saving/loading frames")
+    frames = round_data["frames"]
+
+    for i, frame in enumerate(frames or []):
+        tmp_frame_filename = f"{AWPY_TMP_FOLDER}/frame_{i}.png"
+
+        # Save current frame map control viz to file
+        # All frames are saved to './csgo_tmp/ folder '
+        tmp_fig, _ = plot_frame_map_control(map_name, frame, plot_type=plot_type)
+        tmp_fig.savefig(fname=tmp_frame_filename, bbox_inches="tight", dpi=400)
+        plt.close()
+        # Load image back as frame of gif that will
+        # be created at the end of this function
+        images.append(imageio.imread(tmp_frame_filename))
+
+    print("Creating gif!")
+    imageio.imwrite(filename, images)
+    return True
+
+
+def _plot_map_control_metrics(
+    metrics: list[float],
+    axes: plt.Axes,
+) -> None:
+    """Helper function to plot map control metrics.
+
+    Args:
+        metrics (list): List containing map control values to plot
+        axes (axes): axes object for plotting
+
+    Returns: Nothing, all plotting is done on ax_object
+    """
+    x = list(range(1, len(metrics) + 1))
+    axes.plot(x, metrics)
+    axes.set_ylim(-1, 1)
+    axes.set_xlim(1, len(metrics) + 1)
+    axes.axhline(y=0, linestyle="--", c="k")
+    axes.set_ylabel("Map Control Metric Value", fontdict={"fontsize": 8})
+    yticks = [-1, -0.5, 0, 0.5, 1]
+    yticklabels = [str(abs(tick)) for tick in yticks]
+    axes.set_yticks(yticks)
+    axes.set_yticklabels(yticklabels)
+
+    axes.set_xlabel("Frame Number", fontdict={"fontsize": 8})
+    axes.set_title("Map Control Metric Progress", fontdict={"fontsize": 10})
+    axes.set_xticks([int(i) for i in axes.get_xticks()])
+
+    axes.text(
+        0.025,
+        0.05,
+        "More T Control",
+        fontsize=6,
+        transform=axes.transAxes,
+        verticalalignment="center",
+    )
+    axes.text(
+        0.025,
+        0.95,
+        "More CT Control",
+        fontsize=6,
+        transform=axes.transAxes,
+        verticalalignment="center",
+    )
+
+
+def plot_map_control_metrics(
+    metric_arr: list[float],
+    given_fig_ax: tuple[plt.Figure, plt.Axes] | tuple[None, None] = (None, None),
+) -> None:
+    """Function to plot given map control metrics.
+
+    Args:
+        metric_arr (list): List containing map control values to plot
+        given_fig_ax (tuple): Fig and ax objects if given
+
+    Returns: Plot given map control metric values onto axes object
+
+    Raises:
+        ValueError: If metrics is empty
+    """
+    if not metric_arr:
+        msg = "Metrics is empty."
+        raise ValueError(msg)
+
+    if given_fig_ax[0] is not None:
+        _plot_map_control_metrics(metric_arr, given_fig_ax[1])
+    else:
+        _, curr_ax = plt.subplots()
+        _plot_map_control_metrics(metric_arr, curr_ax)
+        plt.show()
diff --git a/examples/05_Map_Control_Calculations_And_Visualizations.ipynb b/examples/05_Map_Control_Calculations_And_Visualizations.ipynb
new file mode 100644
index 000000000..f415f0e91
--- /dev/null
+++ b/examples/05_Map_Control_Calculations_And_Visualizations.ipynb
@@ -0,0 +1,267 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "95e0d043",
+   "metadata": {},
+   "source": [
+    "### Import Libraries"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "6b14050d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "sys.path.append('../')\n",
+    "\n",
+    "from awpy.parser.demoparser import DemoParser\n",
+    "from awpy.analytics.map_control import extract_teams_metadata, calc_frame_map_control_values, calculate_round_map_control_metrics\n",
+    "from awpy.visualization.plot import plot_frame_map_control, plot_round_map_control, plot_map_control_metrics\n",
+    "\n",
+    "import os\n",
+    "import matplotlib\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dd10d505",
+   "metadata": {},
+   "source": [
+    "### Import and Parse Demo"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "383ed86e",
+   "metadata": {},
+   "source": [
+    "The demo used for this notebook is the Inferno match between FaZe and Cloud9 during the Boston Major Final. The demo can be downloaded from HLTV [here](https://www.hltv.org/matches/2318632/faze-vs-cloud9-eleague-major-2018). After downloading the demo, move it to the same folder this notebook is in. This should allow the notebook to access the demo."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "7e93e009",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "demo_filepath = \"faze-vs-cloud9-m3-inferno.dem\"\n",
+    "demo_parser = DemoParser(demofile = demo_filepath, demo_id = \"Faze-C9-Inferno\", parse_rate=128)\n",
+    "\n",
+    "# Parse the demofile, output results to a dictionary and a dataframe.\n",
+    "#data_df = demo_parser.parse(return_type=\"df\")\n",
+    "data = demo_parser.parse()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "18815fc5",
+   "metadata": {},
+   "source": [
+    "### Calculate and Visualize Frame Map Control Values"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9dc9b159",
+   "metadata": {},
+   "source": [
+    "The following functions can be used to visualize the map control progress for an entire round.\n",
+    "\n",
+    "* `extract_player_positions` can be used to extract alive player positions for both teams\n",
+    "* `calc_map_control` can be used to calculate map control values for each side for a given frame\n",
+    "* `plot_map_control_snapshot` can be used to visualize map control and player positions for a given set of map control dictionaries  \n",
+    "* `plot_frame_map_control` can be used to visualize map control and player positions for a given frame"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "c8675f09",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "'''\n",
+    "Parse frame to extract alive player locations\n",
+    "'''\n",
+    "player_positions = extract_teams_metadata(data['gameRounds'][16]['frames'][8])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "c222deba",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "'''\n",
+    "Calculate map control values for tiles based on\n",
+    "current player positions in given frame\n",
+    "'''\n",
+    "map_control_values = calc_frame_map_control_values(data['mapName'], data['gameRounds'][16]['frames'][8])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "5b7e0497",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/xb/h1d9f0cd4fq2pwq3r5y3s2000000gn/T/ipykernel_30859/776804216.py:6: UserWarning: Matplotlib is currently using module://matplotlib_inline.backend_inline, which is a non-GUI backend, so cannot show the figure.\n",
+      "  map_control_fig.show()\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "'''\n",
+    "Visualize map control given awpy frame\n",
+    "'''\n",
+    "testFrame = data['gameRounds'][16]['frames'][8]\n",
+    "map_control_fig, map_control_axes = plot_frame_map_control(data['mapName'], testFrame, plot_type = 'players')\n",
+    "map_control_fig.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1f41d0e6",
+   "metadata": {},
+   "source": [
+    "### Visualize Map Control for Round"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4e826177",
+   "metadata": {},
+   "source": [
+    "The following functions can be used to visualize the map control progress for an entire round.\n",
+    "\n",
+    "* `create_round_map_control_gif` can be used to save a gif to file whose individual frames are similar to the above visualizations. \n",
+    "* `calculate_round_map_control_metrics` can be used to return a list of map control metrics for a given awpy round\n",
+    "* `plot_map_control_metrics` can be used to generate a plot for a given list of map control metrics\n",
+    "* `save_map_control_graphic` can be used to generate a map control graphic (gif including minimap visualization and map control metric plot) for an entire round and save it to file"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "ba355586",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving/loading frames\n",
+      "Creating gif!\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "'''\n",
+    "Create map control gif for a given awpy frame\n",
+    "'''\n",
+    "\n",
+    "testRound = data['gameRounds'][16]\n",
+    "plot_round_map_control('./results/anubis_map_control_1_20.gif',\n",
+    "                       data['mapName'], testRound, plot_type='players')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "e11df34e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "'''\n",
+    "Generate map control metrics for each frame\n",
+    "in a given awpy round\n",
+    "'''\n",
+    "mcMetrics = calculate_round_map_control_metrics(data['mapName'], data['gameRounds'][29])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "98327745",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAHACAYAAABKwtdzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABsmElEQVR4nO3deVhU9f4H8PeBYd9ckE0WEREUFBDU3Ldyyd0sK3NJs8zSTEvzdvtZtmjeLDOvdi3D0korcUktc8ddZHFDBBQEWUQQ2WFmmPP7Y+DoyCKDDNu8X88zz+Oc+Z4zn/kOznzmuwqiKIogIiIi0iMGDR0AERERUX1jAkRERER6hwkQERER6R0mQERERKR3mAARERGR3mECRERERHqHCRARERHpHSZAREREpHeYABEREZHeYQJERA1q06ZNaNGiRUOHUaXGHh8R1Q4TIKLHNH36dAiCgNmzZ1d4bM6cORAEAdOnT6+XWOLj4/Hyyy/D2dkZJiYmcHd3xwsvvIDz58/X6fO0a9cOq1evrtNrVkcQBAiCgDNnzmgcLykpQevWrSEIAo4ePVrj602fPh3jxo2rUdlJkyYhNjZWi2g1bdq0SYpfEAQ4OjriueeeQ0JCQq2vSUSPjwkQUR1wcXHB1q1bUVRUJB0rLi7Gr7/+CldX13qJ4fz58wgMDERsbCz+97//ITo6Gjt27IC3tzcWLlxYLzE8qLS0FCqVqs6u5+LiguDgYI1jO3bsgKWlZZ09x8MUCgXMzMxgZ2f3WNextrZGWloaUlNT8csvvyAqKgpjxoxBaWlphbKiKEKpVD7W81Wlrt8ToqaMCRBRHejWrRtcXV0REhIiHQsJCYGLiwsCAgI0yv7999/o27cvWrRogdatW2PUqFG4fv269HhiYiIEQcDWrVvRu3dvmJqawsfHp9oWDlEUMX36dHh6euL48eMYOXIkPDw84O/vj6VLl2LXrl1S2UuXLmHw4MEwMzND69at8eqrryI/P196vLx15IsvvoCjoyNat26NN954AwqFAgAwcOBA3Lx5E2+//bbUqgHc7yras2cPOnfuDBMTE9y8eRPZ2dmYOnUqWrZsCXNzc4wYMQJxcXFa1/G0adMqJJk//PADpk2bVqFsSkoKJk2ahJYtW6J169YYO3YsEhMTAQAffvghfvzxR+zatUuK/+jRo1K9//bbbxg4cCBMTU2xZcuWSrvAdu/ejaCgIJiamsLW1hYTJkyoNnZBEODg4ABHR0cMGjQIS5cuxeXLlxEfH4+jR49CEATs378fQUFBMDExwfHjx1FSUoJ58+bBzs4Opqam6Nu3L8LCwirE4enpCTMzMwwaNAg//vgjBEHAvXv3qn1P5HI5Fi1ahLZt28LCwgI9e/bU+Pu6efMmRo8ejZYtW8LCwgI+Pj7Yt28fACA7OxuTJ09GmzZtYGZmBk9PzwqJKVFTwASIqI68/PLLGl8EP/zwA2bMmFGhXEFBARYsWICwsDAcOnQIBgYGGD9+fIVf5u+++y4WLlyIyMhI9O7dG2PGjEFWVlalzx0VFYUrV65g4cKFMDCo+N+6/Au8sLAQw4cPR8uWLREWFobff/8dBw8exJtvvqlR/siRI7h+/TqOHDmCH3/8EZs2bcKmTZsAqBM7Z2dnLFu2DGlpaUhLS5POKywsxPLly/H999/jypUrsLOzw/Tp03H+/Hns3r0bp0+fhiiKePrpp6WEqqYCAwPh7u6O7du3AwCSk5MRGhqKKVOmaJQrLCzEoEGDYGlpidDQUJw4cQKWlpYYPnw45HI53nnnHTz33HMYPny4FH/v3r2l8xcvXox58+bh6tWrGDZsWIU49u7diwkTJmDkyJGIjIzEoUOHEBQUpNVrMTMzAwCNOli0aBGWL1+Oq1evomvXrli0aBG2b9+OH3/8EREREejQoQOGDRuGu3fvAlAnyhMnTsS4ceMQFRWF1157De+//36F56rsPXn55Zdx8uRJbN26FRcvXsSzzz6L4cOHS4npG2+8gZKSEoSGhuLSpUv4/PPPpZa2Dz74ANHR0fjrr79w9epVrF+/Hra2tlq9fqJGQSSixzJt2jRx7Nix4p07d0QTExMxISFBTExMFE1NTcU7d+6IY8eOFadNm1bl+RkZGSIA8dKlS6IoimJCQoIIQFyxYoVURqFQiM7OzuLnn39e6TW2bdsmAhAjIiKqjXXDhg1iy5Ytxfz8fOnY3r17RQMDAzE9PV16PW5ubqJSqZTKPPvss+KkSZOk+25ubuJXX32lce3g4GARgBgVFSUdi42NFQGIJ0+elI5lZmaKZmZm4m+//SadZ2NjU23cAMQdO3aIq1evFgcNGiSKoih+9NFH4vjx48Xs7GwRgHjkyBFRFEVx48aNopeXl6hSqaTzS0pKRDMzM3H//v3Saxw7dqzGc5TX++rVqyu8rgfj69Wrlzh58uRq463u/OTkZPGJJ54QnZ2dxZKSEvHIkSMiAHHnzp1Smfz8fNHIyEj8+eefpWNyuVx0cnISV65cKYqiKC5evFj09fXVeK73339fBCBmZ2dLz/3wexIfHy8KgiCmpKRonDtkyBBxyZIloiiKYpcuXcQPP/yw0tczevRo8eWXX67x6ydqrNgCRFRHbG1tMXLkSPz4448IDg7GyJEjK/1lfP36dbz44oto3749rK2t4e7uDgBISkrSKNerVy/p3zKZDEFBQbh69Wqlzy2KIgBI3VFVuXr1Kvz8/GBhYSEd69OnD1QqFa5duyYd8/HxgaGhoXTf0dERGRkZ1V4bAIyNjdG1a1eN55PJZOjZs6d0rHXr1vDy8qrytVTnpZdewunTp3Hjxg1s2rSp0ha28PBwxMfHw8rKCpaWlrC0tESrVq1QXFys0dVYlUe15kRFRWHIkCFaxZ2TkwNLS0tYWFjAxcUFcrkcISEhMDY2rvR5r1+/DoVCgT59+kjHjIyM0KNHD6nerl27hu7du2s8T48ePSo898PvSUREBERRRMeOHaX6sbS0xLFjx6T6mTdvHj755BP06dMHS5cuxcWLF6XzX3/9dWzduhX+/v5YtGgRTp06pVVdEDUWsoYOgKg5mTFjhtSd9N///rfSMqNHj4aLiwu+++47ODk5QaVSwdfXF3K5/JHXryrB6dixIwB1wuHv71/l+aIoVnmNB48bGRlVeKwmg2fNzMw0rlOemGkTR3XKx0zNnDkTxcXFGDFiBPLy8jTKqFQqBAYG4ueff65wfps2bR75HA8mh5Up777ShpWVFSIiImBgYAB7e/tKn+PBY1UltA/WW2V1WFl9P/yeqFQqGBoaIjw8XCPJBSB1c73yyisYNmwY9u7di3/++QfLly/HqlWrMHfuXIwYMQI3b97E3r17cfDgQQwZMgRvvPEGvvjiC22qhKjBsQWIqA6VjzORy+WVjh/JysrC1atX8e9//xtDhgxBp06dkJ2dXem1HpzyrVQqER4eDm9v70rL+vv7o3Pnzli1alWliUr5oNjOnTsjKioKBQUF0mMnT56EgYGBlETVhLGxcaUzmB7WuXNnKJVKnD17VjqWlZWF2NhYdOrUqcbP96AZM2bg6NGjmDp1aoUvcEA9ID0uLg52dnbo0KGDxs3Gxkar+CvTtWtXHDp0SKtzDAwM0KFDB7Rv3/6RCRYAdOjQAcbGxjhx4oR0TKFQ4Pz581K9eXt7VxgUXZPlDgICAlBaWoqMjIwK9ePg4CCVc3FxwezZsxESEoKFCxfiu+++kx5r06YNpk+fji1btmD16tXYsGHDI5+XqLFhAkRUhwwNDXH16lVcvXq10i/n8llJGzZsQHx8PA4fPowFCxZUeq3//ve/2LFjB2JiYvDGG28gOzu70i4fQN1SEBwcjNjYWPTv3x/79u3DjRs3cPHiRXz66acYO3YsAGDy5MkwNTXFtGnTcPnyZRw5cgRz587FlClTYG9vX+PX2a5dO4SGhiIlJQWZmZlVlvP09MTYsWMxa9YsnDhxAhcuXMBLL72Etm3bSjFpa/jw4bhz5w6WLVtW6eOTJ0+Gra0txo4di+PHjyMhIQHHjh3DW2+9hVu3bknxX7x4EdeuXUNmZqZWA7KXLl2KX3/9FUuXLsXVq1dx6dIlrFy5slavpSoWFhZ4/fXX8e677+Lvv/9GdHQ0Zs2ahcLCQsycORMA8NprryEmJgaLFy9GbGwsfvvtN2mgenWtax07dsTkyZMxdepUhISEICEhAWFhYfj888+lmV7z58/H/v37kZCQgIiICBw+fFhKvP7v//4Pu3btQnx8PK5cuYI9e/bUOpklakhMgIjqmLW1NaytrSt9zMDAAFu3bkV4eDh8fX3x9ttv4z//+U+lZVesWIHPP/8cfn5+OH78OHbt2lXtbJsePXrg/Pnz8PDwwKxZs9CpUyeMGTMGV65ckRYtNDc3x/79+3H37l10794dEydOxJAhQ7B27VqtXuOyZcuQmJgIDw+PR3YrBQcHIzAwEKNGjUKvXr0giiL27dtXoZutpgRBgK2trcb4mQeZm5sjNDQUrq6umDBhAjp16oQZM2agqKhIel9mzZoFLy8vBAUFoU2bNjh58mSNn3/gwIH4/fffsXv3bvj7+2Pw4MEaLVx1ZcWKFXjmmWcwZcoUdOvWDfHx8di/fz9atmwJAHB3d8cff/yBkJAQdO3aFevXr5dmgZmYmFR77eDgYEydOhULFy6El5cXxowZg7Nnz8LFxQWAer2gN954A506dcLw4cPh5eWFdevWAVC3ni1ZsgRdu3ZF//79YWhoiK1bt9b56yfSNUGsqpOeiBpEYmIi3N3dERkZWe14HqKHffrpp/j222+RnJzc0KEQNXocBE1E1EStW7cO3bt3R+vWrXHy5En85z//qbCmExFVjgkQEVETFRcXh08++QR3796Fq6srFi5ciCVLljR0WERNArvAiIiISO80+kHQoaGhGD16NJycnCAIAnbu3NnQIREREVET1+gToIKCAvj5+Wk9S4WIiIioKo1+DNCIESMwYsSIhg6DiIiImpFGnwBpq6SkBCUlJdJ9lUqFu3fvonXr1rVaep+IiIjqnyiKyMvLg5OTEwwM6r7DqtklQMuXL8dHH33U0GEQERFRHUhOToazs3OdX7dJzQITBAE7duzAuHHjqizzcAtQTk4OXF1dkZycXOXqvERERNS45ObmwsXFBffu3ZP28atLza4FyMTEpNJl4KvbnoCIiIgaJ10NX2n0s8CIiIiI6lqjbwHKz89HfHy8dD8hIQFRUVFo1aoVXF1dGzAyIiIiaqoafQJ0/vx5DBo0SLq/YMECAMC0adOwadOmBoqKiIiImrJGnwANHDgQTWicNhERETUBHANEREREeocJEBEREekdJkBERESkd5gAERERkd5hAkRERER6hwkQERER6R0mQERERKR3mABVITExEYIg4MiRIwAAuVyOli1bYu3atXVyfZVKhY8++ggDBgxA7969MWPGDGzYsAEDBw6Et7c3PD09MXDgQHz99dca5125cgXDhw/HgAED0LdvXxw7dkyr5920aRPkcnmNywcFBWl1fSIioqag0S+E2JCCgoIQEhKCQYMG4eDBg/D09KzReSqVCgYG1eeWGzduRHFxsZTAHDp0CEOGDMGrr76KTZs2IT8/H2+++abGOXK5HK+88gq2bdsGV1dXFBQU4PLly1q9pk2bNmHixIkwNjbWOmYiIqLmgglQNdzc3JCUlARRFLFjxw6MHz9eeuyLL77A9u3bIQgCvvnmGwQGBqJbt27o3bs3cnJy8NVXX+GVV15Bbm4unJyc8OOPP8LQ0FA6f+vWrdixY4d0f8iQIY+M58yZM+jdu7e0B5qFhQV69uwJpVKJqVOnIiUlBRYWFtiyZQtyc3Px4osvwtHREXFxcfjyyy9hYWGBqKgojBgxAhMnTkR2djYSEhKQkZGBlStX4ocffkBYWBiMjIzwww8/wN3dvQ5rk4iIqPHgT/5H6NWrF0JDQ3Hnzh04OjoCANLT07F7926cPHkSv/zyCxYvXgwAyM7Oxvz587F582asWLEC8+bNw+HDhxEQEKCR7ABAbm4urK2ttYolLS0NTk5OFY7v2LEDrq6uOHbsGF544QV88803AICsrCxs27YN27dvx7p169CrVy/4+/vjr7/+wltvvQUAcHV1xV9//YXi4mKkpaXhxIkTWLZsGZYtW6Z1XRERETUVTIAe4ZlnnsHbb7+NgQMHSscSExPh5+cHAwMDtGvXDjk5OQCAli1bokOHDgCA6OhoLF26FAMHDsRvv/2G9PR0jeva2NggNzdXq1icnJyQkpJS4fj169fRvXt3AED37t0RHx8PAPD19YVMJoOLiwuys7MrvWb5eVVdg4iIqDliAvQInp6e6Nu3LyZOnCgda9euHaKioqBSqZCYmIgWLVoAgMYYGm9vb3z22Wc4evQozp49i9dee03jus8//zyWL18u3S8fbF2dJ554AqdPn0ZSUhIAoLCwEOfOnUOHDh0QFhYGAAgLC5PGKgmCIJ1bvqGskZERSktLpePlMVd1DSIiouaIY4BqYM2aNRr3HRwcMHbsWPTp0weCIFR4HADef/99zJo1C0uXLgUArFy5UmNG1YwZM/Dxxx+jf//+UKlU8Pb2xqBBg6qNw8jICN9//z1effVVFBUVQRRFfPrppxg3bhxCQkLQv39/WFhY4Oeff66ydWnMmDF47rnn8Nxzz2kcDwoKgqOjI/r27QuZTIbg4OAa1Q0REVFTJIjlTQPNVG5uLmxsbJCTk6P1mBsiIiJqGLr+/mYXGBEREekdJkBERESkd5gAERERkd5hAkRERER6hwkQERER6R0mQERERKR3mAARERGR3mECRERERHqHCRARERHpHSZAREREpHeYABEREZHeYQJEREREeocJEBEREekdJkBERESkd5gAERERkd5hAkRERER6hwkQERER6R0mQERERKR3mAARERGR3mECRERERHqHCRARERHpHSZAREREpHeYABEREZHeYQJEREREeocJEBEREekdJkBERESkd5gAERERkd5hAkRERER6hwkQERER6R0mQERERKR3mAARERGR3mECRERERHqHCRARERHpHSZAREREpHeYABEREZHeYQJEREREeocJEBEREekdJkBERESkd5gAERERkd5hAkRERER6hwkQERFRLZQoSyGKYkOHQbXEBIiIiEhL2QVy9PzsEOb8HNHQoVAtMQEiIiLSUuztPNwrVOBQTAZKVWwFaoqYABEREWkpv0QJAJArVbiVXdjA0VBtMAEiIiLSUnkCBADxGfkNGAnVFhMgIiIiLTEBavpkDR0AERFRU5NfXH0ClFOkQOq9ovoMqU55O1hBEISGDkOnmAARERFpSaMF6I5mApRTpED/lUeQU6So77DqTPynIyAzZAJERERED3i4C0wURanFJPzmXeQUKWBkKKCFuXFDhUiPwASIiIhISw92geUVK3EnrwR21qYAgMikewCAsf5t8cWzfg0RHtUAB0ETERFp6cEWIEBzHFB5AhTg2qIeIyJtMQEiIiLSUoUEqGwcUKlKRFTyPQBAgEvL+g6LtMAEiIiISEvlCZBHGwsA91uA4jPykV+ihLmxITraWzZYfPRoTICIiIi0VD4GyL+slSfutjoBikzKBgD4ObeAzJBfsY0Z3x0iIiItFZSUJ0A2AO53gXH8T9PBBIiIiEhLeWUJkJ9LCwDAnbwS5BQpEJmsbgEKcOX4n8aOCRAREZEWRFGUxgA5WJvCoWz6e1TyPcSVjQXyL0uMqPFiAkRERKSFQnkpRFH9b0tTGTrYqQc7bw+/BVEEXFqZoY2VSQNGSDXBBIiIiEgL5eN/DATAzMhQSoD2X0kHwOnvTQUTICIiIi2Uj/+xNJFBEAR4lCVAJUoVAA6AbiqYABEREWmhfAq8pYl6N6kObTTX++nGAdBNAhMgIiIiLZR3gVmaliVAdvcTIGOZATo5WjdIXKQdJkBERERaeLALDABsLY1hY2YEAOjS1gbGMn61NgV8l4iIiLRQ3gVmUZYACYIgtQIFcPp7k8EEiIiISAsFcnUCZFXWBQYA4/ydYGNmhHEBbRsqLNKS7NFFiIiIqFzeQ4OgAWBKr3aY0qtdA0VEtVHvLUDr1q2Du7s7TE1NERgYiOPHj1dZ9ujRoxAEocItJiamHiMmIiK6r3wVaAsTtiE0ZfWaAG3btg3z58/H+++/j8jISPTr1w8jRoxAUlJSteddu3YNaWlp0s3T07OeIiYiItJUPgbIiglQk1avCdCXX36JmTNn4pVXXkGnTp2wevVquLi4YP369dWeZ2dnBwcHB+lmaGhYTxETERFpengaPDVN9ZYAyeVyhIeHY+jQoRrHhw4dilOnTlV7bkBAABwdHTFkyBAcOXJEl2ESERFV6/40eKMGjoQeR70lQJmZmSgtLYW9vb3GcXt7e6Snp1d6jqOjIzZs2IDt27cjJCQEXl5eGDJkCEJDQ6t8npKSEuTm5mrciIiIauJwzG38Z38MVCqxyjL3p8GzN6Ipq/f2O0EQNO6LoljhWDkvLy94eXlJ93v16oXk5GR88cUX6N+/f6XnLF++HB999FHdBUxERHqhWFGKt7ZGIa9YiT4etujdwbbScpVNg6emp95agGxtbWFoaFihtScjI6NCq1B1nnjiCcTFxVX5+JIlS5CTkyPdkpOTax0zERHpj4NXb0tT3G/eLayy3P29wNgF1pTVWwJkbGyMwMBAHDhwQOP4gQMH0Lt37xpfJzIyEo6OjlU+bmJiAmtra40bERHRo2wPvyX9+1Z21QlQXgm7wJqDem2/W7BgAaZMmYKgoCD06tULGzZsQFJSEmbPng1A3XqTkpKCn376CQCwevVqtGvXDj4+PpDL5diyZQu2b9+O7du312fYj5RbrEB2gRxurS0aOhQiIqqFjLxihMZlSvdvZRdVWbZ8FpgVW4CatHpNgCZNmoSsrCwsW7YMaWlp8PX1xb59++Dm5gYASEtL01gTSC6X45133kFKSgrMzMzg4+ODvXv34umnn67PsB/plR/PI/xmNn5+pSeeaN+6ocMhIiIt7Y5KRalKhMxAgFIlVpkAlapEFMpLAXAafFMniKJY9VD3ZiA3Nxc2NjbIycnRSXdY8t1C9Fupnprv7WCFPXP7QmbILdaIiJqS4atDEZOeh0lBLth2Phl2ViY49/6TFcrlFCng99E/AIBrnwyHiYzdYLqi6+9vflM/pv1X7g/qjknPw69hHHRNRNSURKfmIiY9D8aGBnhtQHsAQEZeCYoVpRXKlnd/GRsaMPlp4pgAPaa/LqsToC5tbQAAX/5zDfcK5Q0ZEhERaWF7hHrw85Od7eBuawFzY3Vik3qvYjdYPleBbjaYAD2GjNxihN/MBgCsm9wNHe0tkV2owOqDVU/TJyKixkNRqsKuqBQAwDPdnCEIApxbmgGofCB0ZTvBU9PEBOgx7I++DQDwd2kBl1bmWDraBwCw+cxNxN7Oa8jQiIioBk7GZyIzX47WFsbo37ENAMClpTmAyhMg7gTffDABegz7y7q/hvs6AAD6dLDF0M72KFWJWPXPtYYMjYiIauBySg4AYEDHNjAqm8ByvwWo4lpA96fAMwFq6pgA1dK9QjlO38gCAAzzcZCOzxnUAQBwNuEumvkEOyKiJi8hU53kuNveX8fNuawFKLmyFqBijgFqLvgO1tLBqxkoVYnwdrDS+I/TydEKRoYC7hUqkHKvSPqPpC/Scorw16V03M4rRla+HFn5Jehob4X3RnhXuecbEVFDScjMBwC4t3kwAaq6BSiPXWDNBt/BWvq7rPvrwdYfADCRGaKjvRWupObickqu3iRAMem52BB6A7ujUqF8aBflI9fuYLSfE3zLZsoRETUWiVnqJKdd64otQJWNASrvAuMg6KaP72AtFJQoERp3B8D98T8P8nWywZXUXFxJzan08eZEpRKx8PcL2BGZIh3r3q4lurRtAVsrY+y/nI4Lt3JwIj6TCRARNSo5hQrcLVAvW6LZBaZuAbpTthaQqdH99X7KB0FzJ/imj+9gLRyPy4RcqYJba3N4O1hVeNy3rTW2nb8/uK45238lHTsiU2AgqJPBV/t7wN+lhfS4mZGhOgGKy8TsAR4NFygR0UMSsgoAAHZWJhpdWi3MjWBpIkN+iRIp94rg0cZSeozT4JsPDoKuhfIp7t3btap0XItPWUvH5dTceo2rvomiiG8OxwMA3hzUAesmB2okPwDQz9MWAHAu8W6lq6oSETUUafyPreZG1g+uBZR8V3McUAHHADUbTIBqITFT/avh4f805To5WMNAUDefZuQW12do9erQ1QxEp+XCwtgQM/q6V1rGo40lHKxNIVeqcD4xu54jJCKqWmUzwMpVtRhiPqfBNxtMgGohsazZ9MFBcw8yMzaUmkwvpzbPbjB16496xespvdqhhblxpeUEQUCfDupWoOPxd+otPiKiR0mo5sdsVQOhOQ2++WACVAs3y2YNuLWueoZX+YDfyynNsxssNC4TF27lwNTIAK/0q7z1p1x5N9jJ+Mz6CI2IqEbKW/PbVdsCpNkFxmnwzQcTIC3lFiuQVTZroLL/NOV8nKwBNM+B0KIo4ptD6tafyT3dYGtpUm353h1aAwCupOZKMy6IiBqSKIpSC1B7LbrAOA2++WACpKWbZX3GtpYm1f4HKG8ButIMB0KfvpGF8zezYSwzwGv92z+yvJ2VKbwdrCCKwKnr6lYgZakKb22NxPDVoZUuNkZEpEuZ+XLklyghCIBLq4qt+VV2gXEafLPBBEhL98f/VL/AYeeyFqCUe0U6b/XYfSEVG08k6PQ5HhR8MhEA8Hx3F9hZm9bonPJxQCfi1AnQ53/HYFdUKmLS8/D6lgjOECOielX+Wd62hZnGOj/lyjdEzcwvQZH8/udT+RggdoE1fUyAtHSz7D+NWxUDoMtZmxpJSdIVHQ6Ezi6QY8G2KHy8JxrxGfk6e54Hn+/otQwAwEtPuNX4vL5l44COx2Vi94VUfHdcnbBZGBviUkoOlu66UvfBEhFVIeFO9bN5rc1k0kyvlHvqVuoSZSnkpSoA7AJrDrRKgFJSUjBu3DgEBgYCAKKiorB69WpdxNVolU+bfFQLEHB/PSBddoMduHpb2noirmx9Il3aeykNilIRnR2t0dG+4iKQVenp3gpGhgJS7hXhnd8vAABeH+iBb6cEwkAAtp1Pxq/nknQVNhGRhvJFEKtKgARBQNvytYDKusEKSu63BDEBavq0SoBee+01TJw4EUqlugnQ19cXGzdu1ElgjVV5C1B1A6DL+TqVzwTTXQvQX5fSpH/H1UML0M6yLS/GB7TV6jxzYxm6ubYEAMiVKvTztMU7Q73Qz7MNFg71AgAs3XUFUcn36jReIqLKlLcAVbWcCVBxHFB595e5sSEMDbi5c1OnVQKUnp6Ol156CQYG6tNkMhlksuaTBX+6NxpLQi5C9dBmng+qbOO8qvi2VY8D0lULUE6RAicemFqu6y6w5LuFOH8zG4IAjPF30vr8AV5tAKhnV6x5PkD6AJkz0ANDO9tDXqrCrJ/OV1h5lYiorpWPAXpwF/iHubTSnAqfzynwzYpWCZBMJoMo3k8OsrOzoVKp6jyohpCWU4Tvjifg13PJOJOQVWmZ/BIlMvNLAACuNekCK2sBSsgsQF6xou6CLXPo6m0oSkWU/xDRdQvQrih1608fD1vY13Dw84Om926HxcO98eusJ9DS4v7CiYIgYNVzfvB2sMKdvBJMCz6HbE6XJyIdUanuT4F3r0kL0N2yFiCuAt2saJUAPfvss5g9ezby8vKwadMmDBs2DDNnztRVbPUq4uY96d8hESmVlilfNKuVhTFszIweec1WFsZo20L9C0IXCyLuu5QOABjtp26NuXEnH6XVtF49DlEUpR3fx2nZ/VXO3FiG1wd6VDrl1MrUCJte7gEnG1PcuFOAmT+GNZmZYQ/+KCCixi89txglShVkBvf3/KqMa9ln1eXUHIiiiPwS9Q9ZrgLdPGiVAC1cuBADBw5EYGAg9u3bh3nz5mHevHm6iq1eRSTd36fqr0tpKJQrK5S5mVXzAdDlurdTj3v5+3LaI0pqJ79EidA49dYSr/ZvD2OZAUqUKqQ8tGZFXbmckovrdwpgIjPAMB97nTyHg40pfpzRA9amMkQk3cPcXyN1ltA9rtu5xfjlbBJmbAqD9wd/Y+amMNwrZKsVUVNQ3vrj2socMsOqvwZ7e7SGpYkMN7MKcep6lrQTvIUxE6DmQOt38YUXXsALL7ygi1gaVPjN+wlQgbwU+6+kY3yAs0aZR+0BVpnx3ZyxMyoVuy+k4v2RnWEsq5uVBw7HZECuVKG9rQU6O1qjva0FYtLzEJeRV6PuOW2Vt/481dkeVqaPbv2qLU97K3w3NQhTNp7Dgejb+PNCaq1bnLRxJCYDS0IuwdzEEG1bmMG5pTkcrE1hYyaDtZkRzI0NkZBZiOi0XFxJzcGNsgGU5Q7FZGD02hP49qVAqeuTiBqnhGq2wHiQhYkM4wPaYvOZm9hy5ib6earHMbIFqHnQ6l18+eWXIQgVR77/8MMPdRZQQyhWlEpr9Uzo1hYhESkIiUipkADVdA2gB/XtYAt7axPczi3B4ZgMDPd1qJOYy2d/jejiAEEQ0MHOEjHpeYjPyMeQTnXbQlOiLMXuC6kAtJ/9VRs927fGm4M74MsDsfhf6A2M9Xeq9O+urly6lYM5P0egqKzL7eHkpjKCAPi7tMCTnezRydEKS3dfQfLdIkxYdwqfju+CZ7q11WnMRFR71W2C+rCXnnDD5jM38U/0bTjaqLvLOAaoedDqXQwKCpL+XVxcjO3btyMgIKDOg6pvV1JzoCgVYWtpjPlDOiIkIgUn4jORllMk/cEDQGL5GkC2NW9hMTQQMC6gLf537Ab+CL+lkQD9cjYJ/wu9jrF+TpjZtz1szGvWslIoV+JI2WKEI3wdAQAd7NS7z9f1TLBSlYj5W6OQmV8CW0tj9O/Ypk6vX5Wpvdyw/uh1XE3LxfG4TJ09763sQsz4MQxFilL087TF7AEeSMkuwq17RbiTV4zcIiVyihTIK1HCpaUZOjtZw8fJBr5O1mj9wB5o3VxbYv62KBy9dgfv/H4BXx+KxTj/thjr31Z6b4hI7dKtHJxNyMIz3Zw1JkTUl+o2QX2Yl4MVurdribDEbPx2PhkAZ4E1F1q9i2+88YbG/ddffx0TJ06s04AaQvkA6ADXlnBtbY4e7q1wLuEudkam4vWBHlK52nSBAcDEbs7437EbOHotA1n5JWhtaYK423n4cPcVyEtVWHM4HsEnE/Fyn3aPTIRyixX4+mAcihUquLYylzZdLf+SrcuZYKIo4l8hl/DX5XQYGxrgq0n+MKqmv7wutTA3xqTuLth0KhEbQm/oJAHKLVZgxqYw3MkrgbeDFdZN7lbr7r0W5sb4YVp3fHM4HhtCryP5bhG+ORyPbw7HY3xAW6x61g8GXDeECCXKUsz8MQwZeSVYeyQeC57qiBd7uFY7FqeuVbcJamVeesINYYnZ0iwwdoE1D4/1F2dmZobExMQ6CqXhlI//KV+o75lu6m6ekIhb0gyfQrkSGXnqKfDaJkCe9lbwc7aBUiViV1QqSlUiFm+/CHmpCt1cW8DbwQp5JUqsORyPUWuPVzoFPDO/BJ//HYM+yw9L+35N6u4idbN42qlXZb6ekV9ns5JW/B2DbeeTYSAAa17wl/q/68vMvu4wNBBwIj6zThaTjM/Ix5u/ROCl789i/LqTGPZVKGJv58POygQ/TO/+2GObDAwEvPWkJ87/+ymseSEAg73tYGggYEdkCtYfu67VtSKSsjUG5hM1F3supEmfpfcKFfi/XVfw9JrjOt0y6EHKUhWS7pa35tfss3y4rwNaP9BSxVWgmwet3sVFixZJ/y4tLcX58+fRuXPnOg+qPomiKH3RBLqpE6ARXRzxf7uuIC4jH5dTctHF2Ubq/mphblTjrqoHPRPojAu3cvBH+C0AQETSPViayLD2xW5wsDbFP9Hp+HjPVSTfLcLbv0Xhh2ndpRaD6NRcTP7+DLIL1VMwO9pbYvYAD4zzvz8ep52tOQwEIK9EnajVZp2ecrdzi/HVgVhsDVM3966Y0BXDy7ra6pNLK3OM7OJYtnfYDXz9/ON1t366NxpHrt3ROGZpIsMP07vDqUXVU2G1ZWZsiDF+Thjj54RtYUlYvP0SVv1zDX7OLaQ90aqTXSDHCxvOQCWKOPLOQGktEqKmThRF6Qfcwqc6ooWFMVb9cw2xt/Px3vZL+HNuX53HcCu7CEqVCBOZARxr+DlpIjPEs0Eu+Lbshwx3gm8etGoBsrCwkG6tWrXC66+/jl9//VVXsdWLlHtFyMgrgcxAQFdn9ewda1MjDPNRj9VZfTAWpSqxVgOgHzS6qxOMDAVEp+VixV8xAID3RnjDqYUZDAwEDPd1xHdTg2AiM8DRa3ew9kg8AOBaeh5e2ngW2YUKeJXNkPr7rf6Y0M1Zo0vFRGYoxRZ3u/JuMGWpCr+fT5aafx+WmV+Cj/dEo//KI1Ly8/7TnfBcd5davea68Gr/9gCAPRfTpNVYayMhswBHrt2BIACfje+CDVMC8fMrPRG6aBB82+pu1tak7q54LsgZKhGYtzUSaTnqZQrSc4rx2/lkRFbSyhMadwclShUUpSI2nUzUWWxE9e3MjbuITsuFqZEBpvRyw5Qn3BDyem8AQEx6LhSlul9YN+GBoQzadEtP7umK8nkNnAbfPGj1Li5dulRXcTSY8u6vzk7WMDUylI7P6tcef19Ox6GYDHy8Jxp21uoBr+61nGLe0sIYT3ayx1+X0yEvVaGneyu82MNVo0xnJ2t8Ms4X7/5xEV8djEULcyOsORSHuwVydHW2weaZPatdgLGDnSUSMgsQn5FXaUvDir9i8P2JBDjZmOKv+f01rhWdmotJG05L61x0b9cSC57yQi+P1rV6vXXFt60N+nawxYn4TExcfxqGBgJyixUwNjTAd9OCpG7LR/npdCIAYJCXHV7s6Vp94Tq2bKwvrqTm4kpqLqb9cA6mRoa4eEvd3G9pIsO594fA/IEP1KMPtFJtDUvGvCc9Ya3DpQeI6svGEzcAAM90c0YLc3WXkrutBSyMDVEgL0ViZgE8tdhkuTYetQt8VVxamWN0Vyf8eTEVncvGXlLTVqMEaN26ddU+PmfOnDoJpiFEJt0DgApfpF2cbbDqOT/M/TUSm04lws5KnQDVtgUIACYGOuOvy+kwkRlgxTNdK/318WyQC8JvZmNrWDL+b9cVAEBnR2v8NKPHI1ef7mBniQPRtysdCP335TR8X9b0nJpTjKW7LmN1WZdSXrECb/wSgbxiJTo5WuO9Ed7o72nbaKZxzxnogRPxmUjPLdY4/ubPEdg7r98jZ5EUlCjxx3l11+O03u10FWaVTI0MsX5yIEZ9cxyxZa1zggAYGRogv0SJQ1czpNW8VSoRx2LVCZCliQz5JUpsO5eMWWUtYURNVUJmAQ7FqGevzujrLh0XBAGe9laISr6Ha7fzdJ4AJWqxofXDVj3nh3+P7AS7xxhiQI1HjRKgsLCwKh9rLF+StVU+/qebW8WWhNF+TkjLKcJn+2LuD4DWYgr8wwZ72+HD0Z3haW9V7a+PD8f44OKtHESn5cLbwQo/v9JT+rVUHc8qpsInZBbg3d8vAgCGdrbHwau3sTMqFUM62WNUV0e8t/0SEjIL4GRjil9e6dkg01Kr07uDLXbM6Y3cYiWsTWUwMzbE61sikJBZgIW/X8D3U4OqbcoOibiFvBIl2rexQL8Ojx6Dowuurc2xcXp3/Ho2Cd3dW2FIJzv8dOom1h6Jx58XUqUE6GJKDu4WyGFlIsOiEd74YOdlBJ9MwPQ+7eptBh6RLgSfTIAoqj8HPdpoLg3R0d4SUcn3pB8IuqTtDLAHGRkaMPlpRmqUAAUHB+s6jgZRJC9FdNlO7d1cW1RaZla/9riVXYSfTt8E8HgtQIIgYHof90eWMzUyxOaZPfD3lXSM7OJYo+QHuD8V/vqd+x8iRfJSvL4lHHklSvRo1wr/ndwN3xyKw5rD8fj3zsu4lp6HvZfSIDMQsHZyt0aX/JQLeKiFbu2LARi/7hQOx2Rgw/EbmD3Ao9LzRFHEplOJAIBpvdo16FT07u1aoXu7VtL90X5OWHskHkev3UFusQLWpkY4UvYLuV9HWzwb6IyvD8YiNacY+y6lYay/7hehJNKFnEIFfi9rhZ3Zt+JnYMeyVp/Y9Dydx1LTVaCp+dN6JFdERASioqJQXHy/O6KpdIGpVCI2HL8BRxtTOFibIiOvBEqVCHtrE2nT0ocJgoClo32gEkWk3itGFx0OmH1Qa0sTTO7pptU55b+qMvPlyC6Qw9JUhkXbLyImPQ+2lsb45sUAGBkaYO4QTxyNvYOLt3KkwdZLnu5U4/E0jYGPkw0+HO2Df+24hP/svwYjQwPIlSqk5xShUF6KAV5t8GQne4Ql3sX1OwWwNJHhmUDnR1+4Hnk5WMHTzhJxGfn458ptTAx0xtGyBS4HdrSDqZEhpjzRDl8djMX3xxMwxk+3K2IT6cqPpxNRpCiFt4MVelcyrlBKgDJ0mwCVKEuRck89EUHbMUDU/GiVAH3++efYtm0bkpKSMGDAABw4cABDhgxpMglQVoFcmoH1oG6uLav9YjE0EPDJuC66DK1OWJjI0LaFGVLuFSHq1j0En0xEaOwdGBoIWPN8gDQ13qhsUcORa46jWKHCcB8HzOjTrmGDr4UXerjgzI0s7L6Qio/3RGs89nv4LViayKRxUxMDnRvl2h2j/Zzw5YFY/HkhFQO92uBi2XpHA7zUay699IQr1h2Nx6WUHJxNuIsn2jfsoHSiquQUKfDtseuYENBWYxxPXrFCmvr++kCPSj9rvRzU5RMzC1CsKNWYkFKXkrIKIYrq8XW2lo2ztZvqj1aDCjZv3oxTp07B2dkZ27dvR1hYGIyNm84fkUoUMSGgLZ5o3wrtWpvDRGYAmYGAMWXjL5oDj7JusDd+jkBo7B2YGRliw5RA9H5o7ItHG0v898VumNrLDSuf7dokWxYEQcBnE7rg6S4O6NW+NSYEtMWcgR54rX97tG1hhvwSpfRrryEGP9fEqK7q9ZVOxGdiZ2QKRBHwcbKWktXWliZSy9WPZV15RI3RH+G3sP7odUwPDpNWTAbUf7c5RQp4tLHAqK6Vf9baWZnA2lQGlVizvfhq68E9wJriZx7VLa1+EpuamsLU1BQqlQqiKMLLy6tJrQRtb22KLyf5S/dFUYSiVKyzHdobgw5tLBEaeweF8lLYWhpj47Tu8HNpUWnZIZ3s63zj1PpmaSLDusmBFY4vHu6N8KRs/HUpHR3sLBttc3f7NpbwbWuNyym5WH0wDoB6qv6Dpjzhhl/OJuFA9O2yPdlMKrsUUYMqX6cr5V4RPt0bjeUTuiK/RCnNPp072BOGVYzBEwQBXg5WCEvMRuztPJ1NM+f4H3qQVgmQubk5FAoF/P39sXjxYjg7O6OwsPaL0zU0QRBgLGtevwK6ubXADyfVMxw2vdwDrrVct6ipMzAQKgw6bqxGd3XC5ZRc6VfzIG/NLUc6OVrDz6UFLiTfw/bwW3itigHfRA3p9gPLVPx6LhnDfBxwJTUX9woVaG9rIc10rIqn/f0ESFfKp8A31h9EVL9q1PRx4cIFAOr1gORyOVatWoXs7GyEhoZi8+bNOg2QtPO0ryN+e60Xds/tq7fJT1Mzsuv9bUZszIzg71JxMPoLZatxbwtLrrO93ojqUlqOOgEqn426ePtFfH9cvfDhm4M7VNn6U86rfCC0DhOgG9IiiPxspBomQE899RQCAwNx/PhxKJVKtGnTBt999x3++OMP+Pv76zhE0oaBgYAe7q0a5YBfqpxzS3NpH7r+HdtU+kUx2s8JFsaGuJFZgLMJd+s7RKJHul2WAC0b64P2tha4nVuC7EIF2rU2r9E4S097deKky7WAEh/YBoOoRglQSkoKlixZgj179sDFxQVTpkzBsWPHdB0bkd6Y/6QnvOyt8Eola6QA6hl+Y/zVXyJbzyXVZ2hEj6RSifcXi21tgS+e80N5Hv/mYE/IarCIZ3kLUNLdQhTKlY8orb2CEiVu56pjZBcYATVMgIyMjDBx4kTs3bsXMTEx6NSpE1599VV06NABn332ma5jJGr2+nm2wf63+1c5YB1Qb6wKAPsupyOnUFFPkTUuoigi/OZdaXYfNQ6ZBeo11QQBaGNlgm6uLfHVJH/MG+KJcf41m2Xb2tIErcsWYn14Nfu6UN7609LcqMaLy1LzpvX0JycnJ/zrX//CL7/8glatWuH//u//dBEXET3Ez9kG3g5WkCtV2BF5q6HDqXcJmQWY+sM5PLP+NMb99yRyi/UzCWyMbueoW1ZsLU2kLVvG+rfFgqc61qj1p1z5gojXdLAi9INT4IkALROgrKwsrFmzBgEBARg/fjyGDRuG2NhYXcVGRA8QBAEv9FC3Am0NS4ZKpR+DoYsVpfjyQCyGfRWK43GZAIA7eSVYezi+gSOjcuUbFTs85j5ZHcvGAVW2ofPjSuQUeHpIjRKgffv2YeLEiXB3d0doaCg+/fRTJCYm4uOPP0b79tylmqi+jAtoC1MjA8Sk52Hu1kgUK0obNJ6cQgXWHo6r9Bd7YmYBPtt3FV8eiMWOyFuITMpGQYl2YzuSsgox7r8nseZQHOSlKvTv2AYfj/MFoN5c88Yd3W+eSY9WngDZP24C5KC7mWA3HmMTVGqeajRV6N1338XMmTOxfv16tGnT5tEnEJFO2JgZYeVEPyz8LQp7L6bhdk4xvpsa1GCb2C7/6yq2hiXj60NxmDfYE7MHesBQELD5zE2s+CsGRQ8laC3MjfDjyz2qHetULjT2Dub+GomcIgVsLY2xbKwvRvg6QBAEHL56G0eu3cEne6/ih+nddfTqqKbKZ4A52DzeIp263BSVLUD0sBolQFeuXNF1HERUQ2P8nGBraYzXNofj/M1sTFh/CsvG+qCHeyuYyHSzh1JlSpSl2HspDQCgKBWx6kAs9kenw8rECKdvZAEAerq3Qvs2FrhxpwDxGfnIKpBjevA5/D67t7RezMPyS5TYdDIBXx6IhUoE/Fxa4NuXusHR5v6Gxf8e1RnH40JxOCYDR65lVFg9m+pXnXWB2akToNScYuQVK2BlavTYsZXjGCB6GBeLIWqCenvYYvvrvfFycBgSMgswZeM5mBsbordHa4zq6oSx/rrfOf5IzB3kFSvhYG2KRcO98NGf0bickgsAMDMyxJKnvfFSTzcYlM2Hzi9RYvJ3Z3DhVg6m/XAOf7zeS0pqihWlOHrtDv68kIpDMbdRrFABACYFueCjsT4VNsf0aGOJl/u0w3fHE/Dxnmj08bBtVlvaNDW366gLzMbcCPbWJridW4KY9LzHWsn964NxyMgrxpuDO8DcSIbsspmTXAOIyjEBImqiOtpbYcec3vjqYCwOXc1ARl4JDl7NwMGrGbhbIMeMKtYUqiu7L6QAAMb4O2FCN2f07WCLz/ZdRX6JEv8e2blCV4OliQw/TO+OZ/93GjfuFGDqxnMY4+eEk9czEXHzHuSlKqmsu60FXh/ggWeDnKtM5OYO8URIRApu3CnAjshb0jIBVP/SpS6wx0uAAKCrcwsciL6NxX9cxJZXesKphdmjT3pIVn4JvjqonqATEpGCEV0cAAD21iaw4CKxVIZ/CURNmJ21KZZP6ApRFBGdlovfz9/CplOJ+GzfVXR1tkGQjvZCyy1W4ODVDACQVvm1szbF6ucDqj2vtaUJNs/siWfWnUJcRj5WHbg/i9TJxhQjuzpijF9b+La1fmQLlrWpEWb0dcd/9l/DvkvpTIAaUF11gQHAv0d2QnRqLm5kFuDZb0/jl1k94aZlq83FWznSv4sUpQiJUCfrbP2hB2nVZrx06VJkZWVJ9zMzM/HRRx/VeVBEpB1BEODjZIOloztjjJ8TlCoRc36OQEZe8aNProX9l9MhV6rQwc4SPlru3N22hRk2z+yB7u1aYoSvAz4e54tDCwfg5HuD8f7IzujibFPj7rthPvYAgNPXs6TNZKl+FcqVyCtW1719HbQAubW2wG+ze8Hd1gIp94rw7LenEaflrLCo5HsAgAkBbfHNCwFwKovLx8nmseOj5kOrBGjXrl1o3bq1dN/W1hY7d+6s65iIqJYEQcDyCV3gaWeJjLwSzP0lEsoHupbqyq6oVADAuFqONfK0t8Lvs3tj/UuBmPKEGzzaWNbqOh5tLOFuawF5qQrHrt3R+nx6fOXdXxbGhrCqo+6lti3MsO21J+Blb4WMvBJM++GcVgnuhVv3AAD+ri0w2s8JhxYOxPdTg7BgaMc6iY+aB60SoMp2oVYouBorUWNiYSLDt1MCYWkiw9mEu1h9MK5Or5+RW4xT19ULEo7xa1un19aWIAh4qrO6FehAdHqDxqKvpDWAbEzrdOC9nZUptr76BFxamSE1pxhf7L9Wo/NEUcSFshYgP+cWAAAzY0M82dmem0STBq0SoI4dO+LLL7+EKIpQqVRYtWoVvL29dRUbEdWSRxtLfP5MVwDAxhMJuFcor7Nr/3kxDSoR6ObaAq6tzevsurVVngAdjsmAQgetXVS923U4/udhLS2M8em4LgCAH08nSolNdZLvFiG7UAFjQwN4O1rVeUzUfGiVAH399dfYs2cPzMzMYGFhgb///hvffPONrmIjosfwdBcHdHa0RpGiFD+frbsd5HdHqQeUjvVv2Nafct1cW6K1hTFyi5UIS7jb0OHonfSyfcB0kQABQP+ObTDW3wmiCCwJufTILt2osu6vTk7W9bouFjU9WiVATk5OOHz4MLKyspCZmYkDBw7A0dFRV7ER0WMQBAGz+qunwm86lYgS5eNvmxGdmosLt3JgaCBgZNfG8X/f0EDAYG/1Qoj/RN9u4Gj0z+0HusB05YNRnWFjZoTotFz8cDKh2rL3u7844JmqV6MEKCFB/QcXHR2N6Oho3Lx5Ezdv3pTuE1HjNKqrExysTXEnr0QauPw4vj9xAwDwdBdH2Fo+3rYHden+OKDblY5VJN2R1gDSUQsQoN5l/l9Pq4dbfHUgDsl3C6ss+/D4H6Kq1CgBmjt3LgBg5MiRFW6jRo3SaYBEVHtGhgZ4uU87AMD3x288VnJwO7cYf15QJ1EzdbzIorb6ebaBqZEBUu4V4Wpa3e8jRVVLq6NVoB/luSAX9HBvhSJFKdYdvV5pGWWpCpdT1WsA1WS/OdJvNUqA9uzZA1EUcfLkSSQkJGjcbty4oesYiegxPN/DFRbGhoi9nY9jsbWfKv7T6UQoSkV0b9cS/o3sy8XM2BB9O6g3aj7AbrB6dbsOV4GujiAIWPiUehp7SMQtZOWXVCgTezsfxQoVrExk3PWdHkmrMUBPP/20ruIgIh2xMTOSVkn+/nj14yeqUihXSgOpZ/ZtX2ex1aWh5d1gVzkdvr6UqkTcydftIOgH9XBvha7ONihRqrDlTMWB/eXr/3R1sZH2oCOqSo0TIEEQ4OHhobESNBE1DS/3aQdDAwEn4jNxNS1X6/O3h9/CvUIF3FqbS+NtGpvBnewgCMDllFxpXArpVmZ+CUpVIgwEwNbSWOfPJwiC1P26+UwiihWaA/s5/oe0oVULkIWFBQICAjBnzhwsWrRIuhFR4+bSylxqIdkefkurc1UqERtPqFuOZvRxh2Ej/WVta2kidc0duZbRsME0YiXKUvx1KQ1rDsUhMin7scaFlSeabaxMIDPU6uuk1p7u4ggnG1Nk5sux+6GB/eVbYHD8D9WEVstienh4wMPDQ1exEJEOTejmjL8up2PXhVQsebpTjROZA1dvIzGrENamMkwMdNZxlI9niLcdIpPu4dDVDLzQg5ujllOpRETduocdESnYfSEVOUXqFfy/PBCL9rYWGB/QFs8GuWg9jqcuN0GtKSNDA0zv0w6f7YvB9ydu4NkgZwiCgEK5ErFle4axBYhqQqsEaPz48ejatavGsYsXL9ZpQESkGwM6tkELcyPcySvBqeuZ6OfZ5pHnxGfk4b3t6v/jL/Z0g0Uj30pgsLc9vvgnFifjM1GsKIWpkf4uhFesKMXBq7dxJOYOjsVmIDP//mrgDtam6OJsg+Nxd3AjswCrDsTiv0fj8fqADnhtQPsa19vtepoB9rDne7ji64NxiL2dj9C4TAzo2AaXU3KhEgF7axOdD8im5kGrT7Pp06cjIiLikceIqPExlhlgVFdHbDmThB2RKY9MgFLuFWHKxnPILlSgq7MN3hzcoZ4irb1OjlZwtDFFWk4xTt/IwiAvu4YOqUEoSlWYsvEswhKzpWOWJjIM6WSHiYHO6O1hC0MDAfklSvx9OR2/nktC+M1sfHUwFr+HJ+ODUZ0xtLP9I/f2Sq+nGWAPszZVD+z/4WQC3vn9AlpbGCOzbDA2W3+opmqUAGVmZiIjIwPFxcW4evWq1Geck5ODgoICnQZIRHVnfEBbbDmThP2X01E4Tglz48o/AjLzSzDl+7NIyymGRxsLbHq5R5PYSFIQ1KtC/3w2CYevZuhtAvTN4XiEJWbD0kSGF3q4YJC3HYLcWsFYpjlOx9JE3a35TLe22HMxDZ/tu4pb2UV4bXM43hvhjdkDqh/ykN5ALUCAemD/ljM3cSevBHfy7k+JH9JJP99z0l6NPtF+/vlnrF69GqmpqRpT4W1sbDgImqgJ6ebaEi6tzJB8twgHom9Xup+XolSFl4PDcCOzAG1bmGHLKz3RykL3M3zqipQAxWRgmSjW6Q7lTUH4zbtYezgOAPDZhC4Y4+f0yHMEQcBoPycM6WSHrw7E4rvjCVj5dwy6Otugt4dtlefpciPUR3FpZY6db/TBzawCWJjIYGEig62lMdxac/0fqpkaDdt/6623kJCQgH//+98aiyBGRUVh5syZuo6RiOqIIAgYX5b07IxMqbTMuYS7uJSSA2tTGTbP7AFHG7P6DPGx9fawhYlMvSr0tduNY1XoUpWID3dfwZpDcTrdqiOvWIG3tkZBJQITAtrWKPl5kLmxDP96uhMmBjpDJQLzfo2sdkmBhuoCK9fZyRojujiif8c2CHRryeSHtKLVvMUPPvgAu3btwueffw4ASE1NxaVLl3QSGBHpxtgAdQIUGpcpjZt40Mn4TADAk53t0b6NZb3GVhfMjA3Rp4O61eLQ1cYxHf7MjSxsOpWILw/EYmtYss6eZ+muK7iVXQSXVmb4aKxPra4hCAI+HuuLTo7WyMyX441fIqB4aAf2YkUpgk8mIPluEYCG6QIjelxaJUAffvghvv32W2zcuBGA+j/K7NmzdRIYEemGRxtL+DnboFQlYs+FihuklidAfarp+mjsyneHPxzTOBKgvZfSpH8v3X0FV8r2q6pLB6NvIyQyBQYCsHqSP6xMjWp9LTNjQ6yf3A1WpjKE38zG7M3hWH/0On4/n4zgkwkY9MVRfPRnNOSlKnjZW8GttXkdvhKi+qHVqMadO3ciPDwcQUFBAABHR0fk5TWOJmYiqrlxAW1x4VYOdkSlYnqf+xub5hQpcClF/eVc3orSFJUnQJFJ2bhbIK/RGCZFqQpGOljMT1mqwt+X1dtztLe1wI3MArzxcwT+nNv3kUmKKIpIzCpE6r0iFCtKUaJUQakSMcCzDWzM75+rKFXhs31XAQCz+rdHoFurx467na0FVj3rh1c3h+NQTAYOPZRMOtqY4s3BHfBsoItO6o1I17RKgExNTWFoqL/rahA1F6O6OuGTvVdxIfkebtzJl7q6ztzIgkoEPNpYNOm1VJxamMHbwQox6Xn47XxytbOZrt/Jx/ytUbiUkgMbMyO0sTKBo40p5gzsgF4erR87ljM37kpJ2G+ze2Hs2pNIzCrEe9svYe2LARUGaUen5mLvpVRcSM7BxVv3kFusrHDNrs42+O21XtJ6PT+fuYkbmQWwtTTGm4PqbrmCoT4O2DKzJ07EZ6pnW+WXoKBEiZFdHPFiT1e9XmeJmj6tEiA3NzecOHECgiBApVLhs88+Q5cuXXQVGxHpSBsrE/TztMXRa3ewMyoVC8p22Za6v5pw60+5Mf5OiPn7Glb8FYP4jHx8OManwlT+PRdTsfiPiyiQq/eUyilSIKdIgfiMfEQl3cO+t/rBpZVm905aThFamhvX+Mt/7yV1N+MwHwfYWppg7YsBeO5/p7H3UhqiV+Wibwdb9PW0xZ28Evx2PhkXb2l2jxnLDODWyhxmxoYwlRnianouLt7KwQc7L2PlxK7ILVJi9SH1rK+3n+r4WF1flenrqY6PqLnRKgFas2YNpk2bhsuXL8Pc3Bz9+vXDzz//rKvYiEiHxge0VSdAkSl4+0lPCIIgJUDVTX1uKl7t1x7F8lKsPRKPP8JvISzxLhYO9YKxoQGUKhVOX8+Sdrjv4d4KKyZ0gUoUkZFXgv/sv4bIpHtY8FsUtr7aS9o2ZPPpRPzf7isY2LENgl/u8cgYFA90f43q6ggACHBtiY/H+uKDXZeRkFmAhMwCbD5zUzrHyFDAk53s0c+zDbo628DLwUqji+lEXCam/nAWv4ffQleXFkjKKsC9QgU87SwxKcilzuqPqLkTxFrMySwsLIRKpYKlZeOfIZKbmwsbGxvk5OTA2tq6ocMhajQK5UoEfXIQhfJSbH+9N9q2MMMTyw/BQAAiPxiqMcakKTuXcBfzt0YitYrp3K8P9MDCpzpqbOaZlFWIp9ccR36JEu8M7Yg3B3si+GQCPvozWioTMqc3urm2rPa5j8fdwZSN59Dawhhn/zVE4zlyixU4fT0LJ+Iycep6JkxkhpjQrS3GB7RFa0uTaq/77bHrWPFXDIwM1YmZolRE8Mvd9XbhR2qedP39XaMWoOjo6Gof79y5c50EQ0T1x9xYhuE+DgiJTMHOyBRpJ/UubW2aTfIDqFt3/nqrPz7fH4PLKTkwMjSAzECAhYkMU3q5VZo0uLY2x0djfLDw9wv46mAc0nOLseWMurXIycYUqTnFWHfkOr6fFlTtc++9qJ79NdzXocJu6damRhjm44BhPg5av6bX+rfHpVs50uyyfp62GNjx0Xu7EdF9NUqAfH194ezsDJlMVmERL0EQcOPGDZ0ER0S6NS6gLUIiU7DnYirule0Q3rsZjP95mI25ET4br914xQnd2uLItQzsuZgmJT9vDuqA8d3a4skvj+Hg1du4lp4HLwerSs9XlKrw9xV199fIsu6vuiIIAlZO7Cp1ob0/spPerXhN9LhqNHfxpZdegomJCSZNmoR//vlHYzVoJj9ETVdvj9ZoY2WC7EIF9lxUD9bt2wwToNoQBAGfjuuCti3UK2G/NcQTC4d2hEcbS4zwVbfafHvsepXnn7qehXuFCthaGqOn++PPJnuYhYkMIXN649R7g+HtwO59Im3VKAH66aefEBERgfbt22Pq1Kno378/Nm3ahMLCQl3HR0Q6JDM0kLZLEEX1jKNAt+rHtegTG3Mj7JnbFzvf6IO3n+ootbLMGaiear77QiqS72p+DuYWK7Ah9DoW/XEBgLr7q3wQdV0zNTJEyya0TxtRY1LjWWBWVlaYNWsWZs2ahX/++QcvvfQSMjIyuBkqURM3PqAtNp5IAAAEubXk2i4PaWlhXCHJ8G1rg36etjgel4kNoTfwzlAvnL95F8fjMrE9/BbyStRr9zhYm+KVvu0bImwieoQaJ0BKpRK7du3Cxo0bkZSUhIULF+Lll1/WZWwa1q1bh//85z9IS0uDj48PVq9ejX79+tXb8xM1Vz5O1uhgZ4n4jPxmsf5PfZkzsAOOx2Xi57M3seXsTTw4PLKDnSVe7dceYwOcYCJjQknUGNUoAVqwYAF27tyJwYMH49///jd69+6t67g0bNu2DfPnz8e6devQp08f/O9//8OIESMQHR0NV1fXeo2FqLlRj3XxxW/nb+Glnm4NHU6T8UT7VujRrhXOJd4FoN7monu7VhjqY49BXnYw0FG3FxHVjRqtA2RgYAAvLy9YWlpWOtPg3LlzOgmuXM+ePdGtWzesX79eOtapUyeMGzcOy5cvr/bc8nUEUlNTK11HwNDQEKam95f8LygoqPJaBgYGMDMzq1XZwsLCCjPoygmCAHNz81qVLSoqgkqlqrQsAFhYWNSqbHFxMUpLS+ukrLm5ufR3U1JSAqWy4tL+tSlrZmYGAwP1MDa5XA6FQlEnZR/c8kWbsgqFAnK5vMqyJiYmkMlkWpdVKpUoKam4a3s5Y2NjGBkZaV22tLQUxcWVr40DAEZGRjA2Nta6rEqlQlFRUZ2UlclkMDFRr4kjimK14w61KavN//vqymYXyHEp5R46OdqgjZUJPyNqWZafEWr8jNAsq/N1/MQaOHr0aLU3XSopKRENDQ3FkJAQjePz5s0T+/fvX6F8cXGxmJOTI92Sk5NFAFXenn76aY3zzc3Nqyw7YMAAjbK2trZVlg0KCtIo6+bmVmXZzp07a5Tt3LlzlWXd3Nw0ygYFBVVZ1tbWVqPsgAEDqixrbm6uUfbpp5+utt4eNHHixGrL5ufnS2WnTZtWbdmMjAyp7Jw5c6otm5CQIJV95513qi17+fJlqezSpUurLXvu3Dmp7MqVK6ste+TIEans2rVrqy27Z88eqWxwcHC1ZX/77Tep7G+//VZt2eDgYKnsnj17qi27du1aqeyRI0eqLbty5Uqp7Llz56otu3TpUqns5cuXqy37zjvvSGUTEhKqLTtnzhypbEZGRrVlp02bJpXNz8+vtuzEiRM1/oarK8vPCPWNnxH3b/yMUN90/RmRk5MjAhBzcnJEXahRF9iAAQNqUkwnMjMzUVpaCnt7e43j9vb2SE9Pr1B++fLl+Oijj+orPCIiImqCarUVRn1KTU1F27ZtcerUKfTq1Us6/umnn2Lz5s2IiYnRKF9SUqLRvJebmwsXFxd2gWlZls3bbN5mF5j2ZfkZUbuy/IxQ42eEZlldd4E1+gRILpfD3Nwcv//+O8aPHy8df+uttxAVFYVjx45Vez73AiMiImp6dP39XaOFEBuSsbExAgMDceDAAY3jBw4cqPfZaERERNQ81GgM0KNWfH6wuVUXFixYgClTpiAoKAi9evXChg0bkJSUhNmzZ+v0eYmIiKh5qlECVD79vbLeMkEQqu3brQuTJk1CVlYWli1bhrS0NPj6+mLfvn1wc3PT6fMSERFR89ToxwA9Lo4BIiIianp0/f1d460wyqWkpODEiRMQBAF9+/aFk5NTnQdFREREpEtaDYLetWsX/Pz88Ouvv+KXX36Bv78//vzzT13FRkRERKQTWrUAffTRRzhz5gw6dOgAALh+/TqeffZZjB49WifBEREREemCVi1ApaWlUvIDAB4eHtUumkVERETUGGmVANnZ2WHjxo3SbLAff/wRtra2OgmMiIiISFe0SoC+/fZbfPfddzA3N4eZmRm+/fZbbNiwQVexEREREelEjccAlZaWYs+ePThz5gzy8/MhiiKsrKx0GRsRERGRTtS4BcjQ0BDbt28HoF4YkckPERERNVVadYE99dRT2LZtm65iISIiIqoXWq0E3aZNG2RlZcHMzAwWFhYQRRGCICAjI0OXMT4WrgRNRETU9DSqlaDPnz9f5wEQERER1TetusA2b94MNzc3jdvmzZt1FRsRERGRTmiVAIWEhNToGBEREVFjVqMusAMHDuCff/5BamoqFi1aJB3PycnRWWBEREREulKjFiBjY2NYWlpCEARYWFhIN29vb7YAERERUZOj1SywCxcuwM/PT5fx1DnOAiMiImp6GtUsMB8fH2zbtg3Xr1+HUqmUjv/f//1fnQdGREREpCtaJUDPP/880tPT0aNHDxgaGuoqJiIiIiKd0ioBunTpEmJiYiAIgq7iISIiItI5rabBu7q6QqFQ6CoWIiIionqhVQtQx44dMXjwYEyYMAGmpqbS8Tlz5tR5YERERES6olUCVFhYCE9PT1y6dEk6xu4wIiIiamq0SoCCg4N1FQcRERFRvdEqAVIqlfj6669x8OBBCIKAp556CnPnzoVMptVliIiIiBqUVpnLggULcP36dbz22msAgI0bNyIhIQFr1qzRSXBEREREuqBVAnT06FFERUXBwEA9eWzUqFHo1q2bTgIjIiIi0hWtpsGLogiVSqVxX4udNIiIiIgaBa1agIYNG4Zhw4Zh5syZEAQBmzZtwogRI3QVGxEREZFOaLUZqkqlwoYNG3Dw4EGIooinnnoKr776qtQl1hhxM1QiIqKmR9ff3zVKgEpLS1FSUgJzc3ON44WFhTA1NWUCRERERHVK19/fNcpclixZgi1btlQ4/r///Q//+te/6jwoIiIiIl2qUQuQj48PLly4UGG9H6VSiYCAAI2VoRsbtgARERE1PY2iBcjQ0LDSxQ5lMhm3wiAiIqImp0YJUFFREUpKSiocLykpQWFhYZ0HRURERKRLNUqARo0ahXnz5kGpVErHlEol3n77bYwcOVJnwRERERHpQo3WAfrkk08wcuRItG/fHoGBgQCAiIgIuLu7Y+/evToNkIiIiKiuabUO0OHDhxEeHg4ACAwMxODBg3UWWF3hIGgiIqKmp1GsA9SUMQEiIiJqehrFLDAiIiKi5oQJEBEREekdJkBERESkd7TaDV6hUODrr7/GwYMHIQgCnnzyScydOxfGxsa6io+IiIiozmmVAL322mvIysrC66+/DgAIDg5GdHQ0Nm7cqJPgiIiIiHRBqwTozJkzuHLlirT9xahRo9ClSxedBEZERESkK1qNAXJyckJxcbF0Xy6Xw9nZuc6DIiIiItIlrVqA2rdvj169emHSpEkAgN9//x39+/fHunXrAABz5syp+wiJiIiI6pjWg6ADAgIQGxsLAPDz80NOTg7CwsK4KzwRERE1GVolQMHBwbqKg4iIiKjeaJUAAepNUKOiojTGArHri4iIiJoSrRKgzz//HNu2bUNSUhIGDBiAAwcOYMiQIUyAiIiIqEnRahbY5s2bcerUKTg7O2P79u0ICwvjIohERETU5GiVAJmamsLU1BQqlQqiKMLLywuJiYk6Co2IiIhIN7TqAjM3N4dCoYC/vz8WL14MZ2dnFBYW6io2IiIiIp3QqgVo3bp1kMvlWLVqFbKzsxEaGorNmzfrKjYiIiIinRBEURQbOghdys3NhY2NDXJycmBtbd3Q4RAREVEN6Pr7u0ZdYIsWLar28ZUrV9ZJMERERET1oUZdYF988QWOHTsGMzMzWFhYVLgRERERNSU1agE6ePAggoOD8csvv+C5557DjBkz4OHhoevYiIiIiHSiRi1AgwcPxubNmxEeHg5XV1dMnjwZgwYNwtmzZ3UdHxEREVGd02oWmLW1NcaMGYOxY8ciJiYGMTExuoqLiIiISGdqlACVlpZix44dGDVqFJ588kkIgoCIiAhMmzZN1/ERERER1bkajQFq27YtXF1dMWPGDPTv3x8AkJ2djezsbABA586ddRchERERUR2r0TpA7dq1gyAI6hMEAQ+eIggCbty4obsIHxPXASIiImp6GsU6QNzvi4iIiJoTrQZBExERETUHTICIiIhI7zABIiIiIr3DBIiIiIj0DhMgIiIi0jtMgIiIiEjvMAEiIiIivcMEiIiIiPQOEyAiIiLSO0yAiIiISO8wASIiIiK9wwSIiIiI9A4TICIiItI7TICIiIhI7zABIiIiIr3DBIiIiIj0DhMgIiIi0jv1ngCtW7cO7u7uMDU1RWBgII4fP15l2aNHj0IQhAq3mJiYeoyYiIiImpt6TYC2bduG+fPn4/3330dkZCT69euHESNGICkpqdrzrl27hrS0NOnm6elZTxETERFRc1SvCdCXX36JmTNn4pVXXkGnTp2wevVquLi4YP369dWeZ2dnBwcHB+lmaGhYTxETERFRc1RvCZBcLkd4eDiGDh2qcXzo0KE4depUtecGBATA0dERQ4YMwZEjR6otW1JSgtzcXI0bERER0YPqLQHKzMxEaWkp7O3tNY7b29sjPT290nMcHR2xYcMGbN++HSEhIfDy8sKQIUMQGhpa5fMsX74cNjY20s3FxaVOXwcRERE1fbL6fkJBEDTui6JY4Vg5Ly8veHl5Sfd79eqF5ORkfPHFF+jfv3+l5yxZsgQLFiyQ7ufm5jIJIiIiIg311gJka2sLQ0PDCq09GRkZFVqFqvPEE08gLi6uysdNTExgbW2tcSMiIiJ6UL0lQMbGxggMDMSBAwc0jh84cAC9e/eu8XUiIyPh6OhY1+ERERGRHqnXLrAFCxZgypQpCAoKQq9evbBhwwYkJSVh9uzZANTdVykpKfjpp58AAKtXr0a7du3g4+MDuVyOLVu2YPv27di+fXt9hk1ERETNTL0mQJMmTUJWVhaWLVuGtLQ0+Pr6Yt++fXBzcwMApKWlaawJJJfL8c477yAlJQVmZmbw8fHB3r178fTTT9dn2ERERNTMCKIoig0dhC7l5ubCxsYGOTk5HA9ERETUROj6+5t7gREREZHeYQJEREREeocJEBEREekdJkBERESkd5gAERERkd5hAkRERER6hwkQERER6R0mQERERKR3mAARERGR3mECRERERHqHCRARERHpHSZAREREpHeYABEREZHeYQJEREREeocJEBEREekdJkBERESkd5gAERERkd5hAkRERER6hwkQERER6R0mQERERKR3mAARERGR3mECRERERHqHCRARERHpHSZAREREpHeYABEREZHeYQJEREREeocJEBEREekdJkBERESkd5gAERERkd5hAkRERER6hwkQERER6R0mQERERKR3mAARERGR3mECRERERHqHCRARERHpHSZAREREpHeYABEREZHeYQJEREREeocJEBEREekdJkBERESkd5gAERERkd5hAkRERER6hwkQERER6R0mQERERKR3mAARERGR3mECRERERHqHCRARERHpHSZAREREpHeYABEREZHeYQJEREREeocJEBEREekdJkBERESkd5gAERERkd5hAkRERER6hwkQERER6R0mQERERKR3mAARERGR3mECRERERHqHCRARERHpHSZAREREpHeYABEREZHeYQJEREREeocJEBEREekdJkBVSExMhCAIOHLkCABALpejZcuWWLt27WNfe/fu3Rg4cCD8/f3h4uKCgQMHYsmSJRplbt26hQkTJmDgwIF44okn8Mcff2j1HDt37kRGRkaNywcFBWl1fSIioqZM1tABNGZBQUEICQnBoEGDcPDgQXh6etboPJVKBQODqnPLMWPGYMyYMTh69Cj27NmDL774okKZ6dOnY9WqVfDz84NCocDp06e1in3nzp3o0KED7OzstIqNiIhIHzABqoabmxuSkpIgiiJ27NiB8ePHS4998cUX2L59OwRBwDfffIPAwEB069YNvXv3Rk5ODr766iu88soryM3NhZOTE3788UcYGhrW6HmTkpJgY2MDPz8/AICRkRH69+8PAHj77bcRFhYGIyMj/PDDD3B3d0enTp3QrVs3REdHY8GCBejbty/+/vtvXLlyBU8++SS8vLzw119/IT8/H2+99RYuXrxYIXYiIiJ9wqaAR+jVqxdCQ0Nx584dODo6AgDS09Oxe/dunDx5Er/88gsWL14MAMjOzsb8+fOxefNmrFixAvPmzcPhw4cREBCAHTt21Pg509LS4OTkVOF4WFgY0tLScOLECSxbtgzLli2T4lm/fj2OHz+OdevWwd3dHcOHD0dwcDCWL18OADA2NsbevXvRtWvXSmMnIiLSJ0yAHuGZZ57B22+/jYEDB0rHEhMT4efnBwMDA7Rr1w45OTkAgJYtW6JDhw4AgOjoaCxduhQDBw7Eb7/9hvT09Bo/p5OTE1JSUiocv379Orp37w4A6N69O+Lj4wEA7du3h7W1NSwtLSGKYqXXLD+vqtiJiIj0CbvAHsHT0xN9+/bFxIkTcfDgQQBAu3btEBUVBZVKhaSkJLRo0QIANMbWeHt7Y/z48ejXrx8AQKFQ1Pg5XVxckJeXhwsXLsDPzw9KpRKnT59Ghw4dsHPnTgDq1qDyMUmCIFS4hpGREUpLS6X75bFVFTsREZE+YQJUA2vWrNG47+DggLFjx6JPnz4QBKHC4wDw/vvvY9asWVi6dCkAYOXKlVrNtAoODsbcuXORnZ0NuVyOd955BxMmTICjoyP69u0LmUyG4ODgKs8fMWIE5s+fj2HDhsHBwUGr2ImIiJo7Qayqz6SZyM3NhY2NDXJycmBtbd3Q4RAREVEN6Pr7m2OAiIiISO8wASIiIiK9wwSIiIiI9A4TICIiItI7TICIiIhI7zABIiIiIr3DBIiIiIj0DhMgIiIi0jtMgIiIiEjvMAEiIiIivdPoE6DQ0FCMHj0aTk5OEARB2gyUiIiIqLYafQJUUFAAPz8/rF27tqFDISIiomai0e8GP2LECIwYMaKhwyAiIqJmpNG3ABERERHVtUbfAqStkpISlJSUSPdzcnIAALm5uQ0VEhEREWmp/HtbFEWdXL/ZJUDLly/HRx99VOG4i4tLA0RDREREjyMrKws2NjZ1fl1B1FVqpQOCIGDHjh0YN25clWUebgG6d+8e3NzckJSUpJMKbMpyc3Ph4uKC5ORkWFtbN3Q4jQrrpmqsm6qxbqrGuqka66ZyOTk5cHV1RXZ2Nlq0aFHn1292LUAmJiYwMTGpcNzGxoZ/WFWwtrZm3VSBdVM11k3VWDdVY91UjXVTOQMD3QxXbvQJUH5+PuLj46X7CQkJiIqKQqtWreDq6tqAkREREVFT1egToPPnz2PQoEHS/QULFgAApk2bhk2bNjVQVERERNSUNfoEaODAgY81AtzExARLly6ttFtM37Fuqsa6qRrrpmqsm6qxbqrGuqmcruulSQ2CJiIiIqoLXAiRiIiI9A4TICIiItI7TICIiIhI7zABIiIiIr3T7BOgdevWwd3dHaampggMDMTx48cbOqR6tXz5cnTv3h1WVlaws7PDuHHjcO3aNY0yoijiww8/hJOTE8zMzDBw4EBcuXKlgSJuOMuXL4cgCJg/f750TJ/rJiUlBS+99BJat24Nc3Nz+Pv7Izw8XHpcX+tGqVTi3//+N9zd3WFmZob27dtj2bJlUKlUUhl9qZvQ0FCMHj0aTk5OEAQBO3fu1Hi8JvVQUlKCuXPnwtbWFhYWFhgzZgxu3bpVj69CN6qrG4VCgcWLF6NLly6wsLCAk5MTpk6ditTUVI1r6GPdPOy1116DIAhYvXq1xvG6qJtmnQBt27YN8+fPx/vvv4/IyEj069cPI0aMQFJSUkOHVm+OHTuGN954A2fOnMGBAwegVCoxdOhQFBQUSGVWrlyJL7/8EmvXrkVYWBgcHBzw1FNPIS8vrwEjr19hYWHYsGEDunbtqnFcX+smOzsbffr0gZGREf766y9ER0dj1apVGsvR62vdfP755/j222+xdu1aXL16FStXrsR//vMffPPNN1IZfambgoIC+Pn5Ye3atZU+XpN6mD9/Pnbs2IGtW7fixIkTyM/Px6hRo1BaWlpfL0MnqqubwsJCRERE4IMPPkBERARCQkIQGxuLMWPGaJTTx7p50M6dO3H27Fk4OTlVeKxO6kZsxnr06CHOnj1b45i3t7f43nvvNVBEDS8jI0MEIB47dkwURVFUqVSig4ODuGLFCqlMcXGxaGNjI3777bcNFWa9ysvLEz09PcUDBw6IAwYMEN966y1RFPW7bhYvXiz27du3ysf1uW5GjhwpzpgxQ+PYhAkTxJdeekkURf2tGwDijh07pPs1qYd79+6JRkZG4tatW6UyKSkpooGBgfj333/XW+y69nDdVObcuXMiAPHmzZuiKLJubt26JbZt21a8fPmy6ObmJn711VfSY3VVN822BUgulyM8PBxDhw7VOD506FCcOnWqgaJqeDk5OQCAVq1aAVBvLZKenq5RTyYmJhgwYIDe1NMbb7yBkSNH4sknn9Q4rs91s3v3bgQFBeHZZ5+FnZ0dAgIC8N1330mP63Pd9O3bF4cOHUJsbCwA4MKFCzhx4gSefvppAPpdNw+qST2Eh4dDoVBolHFycoKvr69e1RWg/mwWBEFqZdXnulGpVJgyZQreffdd+Pj4VHi8ruqm0a8EXVuZmZkoLS2Fvb29xnF7e3ukp6c3UFQNSxRFLFiwAH379oWvry8ASHVRWT3dvHmz3mOsb1u3bkVERATCwsIqPKbPdXPjxg2sX78eCxYswL/+9S+cO3cO8+bNg4mJCaZOnarXdbN48WLk5OTA29sbhoaGKC0txaeffooXXngBgH7/3TyoJvWQnp4OY2NjtGzZskIZffqcLi4uxnvvvYcXX3xR2gxVn+vm888/h0wmw7x58yp9vK7qptkmQOUEQdC4L4pihWP64s0338TFixdx4sSJCo/pYz0lJyfjrbfewj///ANTU9Mqy+lj3ahUKgQFBeGzzz4DAAQEBODKlStYv349pk6dKpXTx7rZtm0btmzZgl9++QU+Pj6IiorC/Pnz4eTkhGnTpknl9LFuKlObetCnulIoFHj++eehUqmwbt26R5Zv7nUTHh6Or7/+GhEREVq/Tm3rptl2gdna2sLQ0LBCNpiRkVHhF4k+mDt3Lnbv3o0jR47A2dlZOu7g4AAAellP4eHhyMjIQGBgIGQyGWQyGY4dO4Y1a9ZAJpNJr18f68bR0RGdO3fWONapUydpAoE+/928++67eO+99/D888+jS5cumDJlCt5++20sX74cgH7XzYNqUg8ODg6Qy+XIzs6uskxzplAo8NxzzyEhIQEHDhyQWn8A/a2b48ePIyMjA66urtLn8s2bN7Fw4UK0a9cOQN3VTbNNgIyNjREYGIgDBw5oHD9w4AB69+7dQFHVP1EU8eabbyIkJASHDx+Gu7u7xuPu7u5wcHDQqCe5XI5jx441+3oaMmQILl26hKioKOkWFBSEyZMnIyoqCu3bt9fbuunTp0+F5RJiY2Ph5uYGQL//bgoLC2FgoPnRaWhoKE2D1+e6eVBN6iEwMBBGRkYaZdLS0nD58uVmX1flyU9cXBwOHjyI1q1bazyur3UzZcoUXLx4UeNz2cnJCe+++y72798PoA7rRush203I1q1bRSMjI3Hjxo1idHS0OH/+fNHCwkJMTExs6NDqzeuvvy7a2NiIR48eFdPS0qRbYWGhVGbFihWijY2NGBISIl66dEl84YUXREdHRzE3N7cBI28YD84CE0X9rZtz586JMplM/PTTT8W4uDjx559/Fs3NzcUtW7ZIZfS1bqZNmya2bdtW3LNnj5iQkCCGhISItra24qJFi6Qy+lI3eXl5YmRkpBgZGSkCEL/88ksxMjJSmslUk3qYPXu26OzsLB48eFCMiIgQBw8eLPr5+YlKpbKhXladqK5uFAqFOGbMGNHZ2VmMiorS+GwuKSmRrqGPdVOZh2eBiWLd1E2zToBEURT/+9//im5ubqKxsbHYrVs3afq3vgBQ6S04OFgqo1KpxKVLl4oODg6iiYmJ2L9/f/HSpUsNF3QDejgB0ue6+fPPP0VfX1/RxMRE9Pb2Fjds2KDxuL7WTW5urvjWW2+Jrq6uoqmpqdi+fXvx/fff1/ji0pe6OXLkSKWfL9OmTRNFsWb1UFRUJL755ptiq1atRDMzM3HUqFFiUlJSA7yaulVd3SQkJFT52XzkyBHpGvpYN5WpLAGqi7oRRFEUtW+kIiIiImq6mu0YICIiIqKqMAEiIiIivcMEiIiIiPQOEyAiIiLSO0yAiIiISO8wASIiIiK9wwSIiIiI9A4TICKqVrt27eDt7Q1/f3/4+/tj9uzZDR0SAGDgwIGwtbVFTk6OdGzixInYtGlTnT7P9OnTsXbt2jq9JhE1vGa/GzwRPb4//vgDvr6+VT5eWloKQ0PDeoxIzcrKCitWrJA2Im2slEolZDJ+3BI1JmwBIiKtbdq0CcOHD8fUqVMRFBSEc+fO4csvv0T37t0REBCAHj164OzZs1J5QRCwfPly9OjRA+3bt8fBgwexZMkSBAQEwMfHB1euXJHKbt68GT179kS3bt0wYMAAXL58uco4lixZgu+++w6pqakVHvvwww/xzjvvSPfXrl2L6dOnS/EPHToUzz//PLy9vTF48GBcuXIFI0eORMeOHfH8889Lm5sCwIULFzBkyBB4e3tj+vTpKCkpAQDk5eVh1qxZ6NGjB7p27YrZs2dDoVAAULdQvf/++xgyZAiGDRtWu4omIp1hAkREjzRx4kSpC2zHjh0AgBMnTuCDDz7A+fPn0atXL0yZMgVhYWGIjIzEmjVrMHPmTI1rWFtb49y5c/j8888xduxY9O3bF5GRkZg2bRo+/fRTAMDJkyexdetWhIaGIiIiAp988gkmT55cZVxOTk549dVXsXTpUq1fU1hYGL744gvExMTA3NwcL774In755RdER0cjOjoaBw8elMqePXsWu3btwpUrV3D37l18/fXXAICFCxeif//+OHfuHC5cuAClUqnRXRYVFYW///4bhw4d0jo+ItIttskS0SM93AW2adMm9O3bF56entKxyMhIfPrpp8jKyoJMJkN0dDTkcjmMjY0BAJMmTQIAdOvWDQYGBhg5ciQAIDAwECEhIQCAXbt24cKFC+jZs6d03Tt37mhc52GLFy+Gl5cXYmJitHpNffr0gbOzMwAgICAA7dq1g42NDQDAz88PN27ckMpOmjQJlpaWAIAZM2Zg3bp1WLRoEXbu3IkzZ85g1apVAICioiKNOKdMmQIjIyOt4iKi+sEEiIhqpTwhAAC5XI5nnnkGR48eRWBgIHJzc2FjY6ORuJiamgIADA0NYWJiIp1raGgIpVIJABBFETNmzMCyZctqHIeNjQ0WLVqEJUuWaIxDkslkKC0tle4XFxdrnFceT3kMD98vj6kygiBI8e7cuRPt27evtNyDdUREjQu7wIjosRUXF0OhUMDFxQUA8M0339TqOqNHj8ZPP/2E5ORkAIBKpcL58+cfed4bb7yByMhIhIeHS8c8PDxw/vx5qFQqFBYWYvv27bWKCQB+//13FBQUoLS0FMHBwXjyyScBAGPGjMGKFSukZCk7Oxvx8fG1fh4iqj9MgIjosVlbW2PZsmXo0aMH+vfvr9HCo43+/fvjs88+w9ixY+Hn5wdfX19s27btkeeZmJjg448/RmJionTsmWeegZ2dHTp37owJEybA39+/VjGVxzVu3Dj4+PigZcuWmDt3LgBg9erVkMlk8Pf3R9euXfHkk09qxEBEjZcgiqLY0EEQERER1Se2ABEREZHeYQJEREREeocJEBEREekdJkBERESkd5gAERERkd5hAkRERER6hwkQERER6R0mQERERKR3mAARERGR3mECRERERHqHCRARERHpnf8HLK7Pjc2DsQAAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "'''\n",
+    "Create plot for given list of map control metrics\n",
+    "'''\n",
+    "plot_map_control_metrics(mcMetrics)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "552b9c10",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python [conda env:awpyTest]",
+   "language": "python",
+   "name": "conda-env-awpyTest-py"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/pyproject.toml b/pyproject.toml
index a3f68bca9..d9abbb36c 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -189,7 +189,8 @@ testpaths = ["tests"]
 
 [tool.pylint.main]
 # Specify a score threshold under which the program will exit with error.
-fail-under = 9.99
+fail-under              = 9.99
+extension-pkg-allow-list = ["cv2"]
 
 [tool.pylint.basic]
 # Good variable names which should always be accepted, separated by a comma.
@@ -280,3 +281,6 @@ min-similarity-lines = 4
 [tool.pylint.spelling]
 # Limits count of emitted suggestions for spelling mistakes.
 max-spelling-suggestions = 4
+
+[tool.pylint.typecheck]
+generated-members = ["cv2.*"]
diff --git a/tests/test_map_control.py b/tests/test_map_control.py
new file mode 100644
index 000000000..9b1bfcf0e
--- /dev/null
+++ b/tests/test_map_control.py
@@ -0,0 +1,227 @@
+"""Tests map control functionality."""
+import pytest
+
+from awpy.analytics.map_control import (
+    _approximate_neighbors,
+    _bfs,
+    calc_frame_map_control_metric,
+    calc_frame_map_control_values,
+    calc_parsed_frame_map_control_values,
+    calculate_round_map_control_metrics,
+    extract_teams_metadata,
+    graph_to_tile_neighbors,
+)
+from awpy.data import NAV_GRAPHS
+
+
+class TestMapControl:
+    """Class to test the map control-related functions."""
+
+    def setup_class(self):
+        """Setup class by defining custom Map Control object."""
+        self.fake_alive_player = {
+            "x": -42.51047897338867,
+            "y": 868.4791870117188,
+            "z": 54.92256546020508,
+            "isAlive": True,
+        }
+        self.fake_dead_player = {
+            "x": -42.51047897338867,
+            "y": 868.4791870117188,
+            "z": 54.92256546020508,
+            "isAlive": False,
+        }
+        self.fake_frames = {
+            "map_control_sanity_t_control": {
+                "t": {"players": [self.fake_alive_player.copy()] * 5},
+                "ct": {"players": [self.fake_alive_player.copy()]},
+            },
+            "map_control_sanity_ct_control": {
+                "ct": {"players": [self.fake_alive_player.copy()] * 5},
+                "t": {"players": [self.fake_alive_player.copy()]},
+            },
+            "map_control_null_5v0": {
+                "t": {"players": [self.fake_alive_player.copy()] * 5},
+                "ct": {"players": []},
+            },
+            "map_control_null_1v0": {
+                "t": {"players": [self.fake_alive_player.copy()]},
+                "ct": {"players": []},
+            },
+        }
+        self.isolated_tiles_inferno = [850]
+        self.connected_tiles_inferno = [2641, 277]
+
+    def test_calc_frame_map_control_metric_sanity_t_control(self):
+        """Tests calc_frame_map_control_metric with T 5v1 scenario."""
+        with pytest.raises(ValueError, match="Map not found."):
+            calc_frame_map_control_metric(
+                map_name="de_mock",
+                frame=self.fake_frames["map_control_sanity_t_control"],
+            )
+        test_map_control_metric = calc_frame_map_control_metric(
+            map_name="de_inferno",
+            frame=self.fake_frames["map_control_sanity_t_control"],
+        )
+        assert test_map_control_metric < 0  # Map Control is T sided
+
+    def test_calc_frame_map_control_metric_sanity_ct_control(self):
+        """Tests calc_frame_map_control_metric with CT 5v1 scenario."""
+        with pytest.raises(ValueError, match="Map not found."):
+            calc_frame_map_control_metric(
+                map_name="de_mock",
+                frame=self.fake_frames["map_control_sanity_ct_control"],
+            )
+        test_map_control_metric = calc_frame_map_control_metric(
+            map_name="de_inferno",
+            frame=self.fake_frames["map_control_sanity_ct_control"],
+        )
+        assert test_map_control_metric > 0  # Map Control is CT sided
+
+    def test_calc_frame_map_control_metric_null_5v0(self):
+        """Tests calc_frame_map_control_metric with T 5v0 scenario."""
+        with pytest.raises(ValueError, match="Map not found."):
+            calc_frame_map_control_metric(
+                map_name="de_mock", frame=self.fake_frames["map_control_null_5v0"]
+            )
+        test_mc_metric = calc_frame_map_control_metric(
+            map_name="de_inferno", frame=self.fake_frames["map_control_null_5v0"]
+        )
+        assert test_mc_metric == -1  # Map Control is complete T
+
+    def test_calc_frame_map_control_metric_null_1v0(self):
+        """Tests calc_frame_map_control_metric with T 1v0 scenario."""
+        with pytest.raises(ValueError, match="Map not found."):
+            calc_frame_map_control_metric(
+                map_name="de_mock", frame=self.fake_frames["map_control_null_1v0"]
+            )
+        test_mc_metric = calc_frame_map_control_metric(
+            map_name="de_inferno", frame=self.fake_frames["map_control_null_1v0"]
+        )
+        assert test_mc_metric == -1  # Map Control is complete T
+
+    def test_calc_frame_map_control_values(self):
+        """Tests calc_frame_map_control_metric with T 5v1 scenario.
+
+        Simple sanity checks to ensure function runs - Doesn't check
+        on FrameMapControlValues object individually but instead asserts on
+        size of the keys of the TeamMapControlValues object for each side
+        """
+        with pytest.raises(ValueError, match="Map not found."):
+            calc_frame_map_control_values(
+                map_name="de_mock",
+                frame=self.fake_frames["map_control_sanity_t_control"],
+            )
+        test_mc_values = calc_frame_map_control_values(
+            map_name="de_inferno",
+            frame=self.fake_frames["map_control_sanity_t_control"],
+        )
+
+        # Sanity check for existence of mc values for T side
+        assert len(test_mc_values.t_values.keys()) > 0
+
+        # Sanity check for existence of mc values for CT side
+        assert len(test_mc_values.ct_values.keys()) > 0
+
+    def test_calc_parsed_frame_map_control_values(self):
+        """Tests calc_parsed_frame_map_control_values with T 5v1 scenario.
+
+        Simple sanity checks to ensure function runs - Doesn't check
+        on FrameMapControlValues object individually but instead asserts on
+        size of the keys of the TeamMapControlValues object for each side
+        """
+        test_team_metadata = extract_teams_metadata(
+            self.fake_frames["map_control_sanity_t_control"]
+        )
+
+        with pytest.raises(ValueError, match="Map not found."):
+            calc_parsed_frame_map_control_values(
+                map_name="de_mock",
+                current_player_data=test_team_metadata,
+            )
+
+        test_mc_values = calc_parsed_frame_map_control_values(
+            map_name="de_inferno",
+            current_player_data=test_team_metadata,
+        )
+
+        # Sanity check for existence of mc values for T side
+        assert len(test_mc_values.t_values.keys()) > 0
+
+        # Sanity check for existence of mc values for CT side
+        assert len(test_mc_values.ct_values.keys()) > 0
+
+    def test_approximate_neighbors(self):
+        """Tests _approximate_neighbors.
+
+        Simple sanity checks to ensure function runs - Doesn't check
+        on neighbors individually but instead asserts on
+        size of TileNeighbors object
+        """
+        with pytest.raises(ValueError, match="Tile ID not found."):
+            _approximate_neighbors(map_name="de_inferno", source_tile_id=0)
+        with pytest.raises(ValueError, match="Invalid n_neighbors value. Must be > 0."):
+            _approximate_neighbors(
+                map_name="de_inferno",
+                source_tile_id=self.connected_tiles_inferno[0],
+                n_neighbors=0,
+            )
+
+        for tile in self.isolated_tiles_inferno + self.connected_tiles_inferno:
+            cur_neighbors = _approximate_neighbors(
+                map_name="de_inferno", source_tile_id=tile
+            )
+            assert len(cur_neighbors) == 5
+
+        for tile in self.isolated_tiles_inferno + self.connected_tiles_inferno:
+            cur_neighbors = _approximate_neighbors(
+                map_name="de_inferno", source_tile_id=tile, n_neighbors=10
+            )
+            assert len(cur_neighbors) == 10
+
+    def test_bfs(self):
+        """Tests _bfs with a couple isolated CT positions.
+
+        Simple sanity check to ensure function runs - Doesn't check
+        on assert map control values individually and instead asserts on
+        size on MapControlValues object
+        """
+        with pytest.raises(
+            ValueError, match="Invalid area_threshold value. Must be > 0."
+        ):
+            _bfs(
+                map_name="de_inferno",
+                current_tiles=self.isolated_tiles_inferno
+                + self.connected_tiles_inferno,
+                neighbor_info=graph_to_tile_neighbors(
+                    list(NAV_GRAPHS["de_inferno"].edges)
+                ),
+                area_threshold=0,
+            )
+
+        sanity_bfs_return = _bfs(
+            map_name="de_inferno",
+            current_tiles=self.isolated_tiles_inferno + self.connected_tiles_inferno,
+            neighbor_info=graph_to_tile_neighbors(list(NAV_GRAPHS["de_inferno"].edges)),
+        )
+        assert len(sanity_bfs_return.keys()) > 0
+
+    def test_calculate_round_map_control_metrics(self):
+        """Tests calculate_round_map_control_metrics with T 5v1 control scenario."""
+        round_length = 50
+        test_round = {
+            "frames": [self.fake_frames["map_control_sanity_t_control"]] * round_length
+        }
+        with pytest.raises(ValueError, match="Map not found."):
+            calculate_round_map_control_metrics(
+                map_name="de_mock",
+                round_data=test_round,
+            )
+        test_map_control_metric_values = calculate_round_map_control_metrics(
+            map_name="de_inferno",
+            round_data=test_round,
+        )
+        assert len(test_map_control_metric_values) == round_length
+
+        for frame_metric in test_map_control_metric_values:
+            assert frame_metric < 0  # Map Control is T sided
diff --git a/tests/test_nav.py b/tests/test_nav.py
index ccfebb11b..d1115d1e6 100644
--- a/tests/test_nav.py
+++ b/tests/test_nav.py
@@ -10,6 +10,8 @@
 
 from awpy.analytics.nav import (
     area_distance,
+    calculate_map_area,
+    calculate_tile_area,
     find_closest_area,
     frame_distance,
     generate_area_distance_matrix,
@@ -73,6 +75,38 @@ def setup_class(self):
             }
         }
 
+        self.fake_tile_area_nav = {
+            "de_mock": {
+                1: {
+                    "areaName": "Place1",
+                    "northWestX": 2,
+                    "northWestY": 2,
+                    "northWestZ": 0,
+                    "southEastX": 0,
+                    "southEastY": 0,
+                    "southEastZ": 0,
+                },
+                2: {
+                    "areaName": "Place2",
+                    "northWestX": 2,
+                    "northWestY": 0,
+                    "northWestZ": 0,
+                    "southEastX": 6,
+                    "southEastY": 2,
+                    "southEastZ": 0,
+                },
+                3: {
+                    "areaName": "Place3",
+                    "northWestX": 6,
+                    "northWestY": 6,
+                    "northWestZ": 0,
+                    "southEastX": 0,
+                    "southEastY": 2,
+                    "southEastZ": 0,
+                },
+            }
+        }
+
         self.dir = os.path.join(os.getcwd(), "nav")
         if not os.path.exists(self.dir):
             os.makedirs(self.dir)
@@ -1956,3 +1990,32 @@ def test_token_distance(self):
         assert token_distance(map_name, token1, token2) == token_state_distance(
             map_name, array1, array2
         )
+
+    def test_calculate_tile_area(self):
+        """Tests calculate_tile_area with known inferno tile."""
+        with pytest.raises(ValueError, match="Map not found."):
+            calculate_tile_area(
+                map_name="de_na",
+                tile_id=1,
+            )
+        with pytest.raises(ValueError, match="Tile ID not found."):
+            calculate_tile_area(
+                map_name="de_inferno",
+                tile_id=1234,
+            )
+        test_map_control_metric = calculate_tile_area(
+            map_name="de_inferno",
+            tile_id=1933,
+        )
+        assert test_map_control_metric == 625
+
+    def test_calculate_map_area(self):
+        """Tests calculate_map_area with inferno."""
+        with pytest.raises(ValueError, match="Map not found."):
+            calculate_map_area(
+                map_name="de_na",
+            )
+        test_map_area = calculate_map_area(
+            map_name="de_inferno",
+        )
+        assert int(test_map_area) == 5924563
diff --git a/tests/test_vis.py b/tests/test_vis.py
index 3531a6bfd..18e28d4e6 100644
--- a/tests/test_vis.py
+++ b/tests/test_vis.py
@@ -9,11 +9,13 @@
 from matplotlib.figure import Figure
 
 from awpy.types import PlotPosition
+from awpy.visualization import AWPY_TMP_FOLDER
 from awpy.visualization.plot import (
     plot_map,
     plot_nades,
     plot_positions,
     plot_round,
+    plot_round_map_control,
     position_transform,
     position_transform_all,
 )
@@ -225,3 +227,42 @@ def test_plot_nades(self):
                 position_transform("de_ancient", -163.84375, "y"),
                 color="red",
             )
+
+    def test_plot_round_map_control(self):
+        """Test plot_round_map_control."""
+        fake_alive_player = {
+            "x": -42.51047897338867,
+            "y": 868.4791870117188,
+            "z": 54.92256546020508,
+            "isAlive": True,
+        }
+        fake_frame = {
+            "t": {"players": [fake_alive_player.copy()] * 5},
+            "ct": {"players": [fake_alive_player.copy()]},
+        }
+
+        round_length = 50
+        test_round = {"frames": [fake_frame] * round_length}
+
+        test_filename = "map_control_test.gif"
+
+        bool_returned = plot_round_map_control(
+            test_filename, "de_inferno", test_round, plot_type="players"
+        )
+
+        assert bool_returned
+        assert os.path.isdir(AWPY_TMP_FOLDER)
+        assert len(os.listdir(AWPY_TMP_FOLDER)) > 0
+
+        awpy_tmp_files = set(os.listdir(AWPY_TMP_FOLDER))
+
+        for i in range(round_length):
+            filename = "frame_" + str(i)
+            filepath = f"{AWPY_TMP_FOLDER}/{filename}.png"
+
+            # Assert temp frame file exists and size > 0 bytes
+            assert filename + ".png" in awpy_tmp_files
+            assert os.stat(filepath).st_size > 0
+
+        # Assert gif is created and size > 0 bytes
+        assert os.stat(test_filename).st_size > 0