diff --git a/.gitignore b/.gitignore
index 6a3f2a9c0333afa4f4e1e48a25605b1333527faf..d73cb8de4f3d0c9f3b15278b1874922df218895c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -60,8 +60,10 @@ irlc/exam/exam2024august/*.pdf
 irlc/exam/exam2025*/*.zip
 irlc/exam/exam2025*/*.pdf
 
-#irlc/exam/midterm2023a
-#irlc/exam/midterm2023b
+irlc/exam/exam2*/solution
+
+irlc/exam/midterm2023a
+irlc/exam/midterm2023b
 
 irlc/lectures/lec01
 irlc/lectures/lec02
diff --git a/irlc/car/car_model.py b/irlc/car/car_model.py
index 2d4567e9ceb693d52a774673a59b08797bc6efc0..2897d6268891cab9da635ca87a298293fdf7d4ad 100644
--- a/irlc/car/car_model.py
+++ b/irlc/car/car_model.py
@@ -91,10 +91,10 @@ class SymbolicBicycleModel(ControlModel):
 
     def x_bound(self) -> Box:
         return Box(np.asarray([-np.inf, -np.inf, -np.inf, -np.inf, -np.inf, -self.map.width]),
-                   np.asarray([self.v_max, np.inf, np.inf, np.inf, np.inf, self.map.width]))
+                   np.asarray([self.v_max, np.inf, np.inf, np.inf, np.inf, self.map.width]), dtype=np.float64)
 
     def u_bound(self) -> Box:
-        return Box(np.asarray([-0.5, -1]),np.asarray([0.5, 1]))
+        return Box(np.asarray([-0.5, -1]),np.asarray([0.5, 1]), dtype=np.float64)
 
     def render(self, x, render_mode='human'):
         if self.viewer == None:
diff --git a/irlc/ex01/__init__.py b/irlc/ex01/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..51d06d4927f23b2f23bf8b39f2b235f268d55ca8
--- /dev/null
+++ b/irlc/ex01/__init__.py
@@ -0,0 +1,2 @@
+# This file may not be shared/redistributed without permission. Please read copyright notice in the git repo. If this file contains other copyright notices disregard this text.
+"""This directory contains the exercises for week 1."""
diff --git a/irlc/ex01/agent.py b/irlc/ex01/agent.py
new file mode 100644
index 0000000000000000000000000000000000000000..6cca61aa985b22c27d8f17b8210c3e8056e04e1a
--- /dev/null
+++ b/irlc/ex01/agent.py
@@ -0,0 +1,385 @@
+# This file may not be shared/redistributed without permission. Please read copyright notice in the git repo. If this file contains other copyright notices disregard this text.
+"""The Agent class.
+
+References:
+  [Her25] Tue Herlau. Sequential decision making. (Freely available online), 2025.
+"""
+import typing
+import itertools
+import os
+import sys
+from collections import OrderedDict, namedtuple
+import numpy as np
+from tqdm import tqdm
+from irlc.utils.common import load_time_series, log_time_series
+from irlc.utils.irlc_plot import existing_runs
+import shutil
+from gymnasium import Env
+from dataclasses import dataclass
+
+class Agent: 
+    r"""The main agent class. See (Her25, Subsection 4.4.3) for additional details.
+
+    To use the agent class, you should first create an environment. In this case we will just create an instance of the
+    ``InventoryEnvironment`` (see (Her25, Subsection 4.2.3))
+
+    :Example:
+
+        .. runblock:: pycon
+
+            >>> from irlc import Agent                                              # You can import directly from top-level package
+            >>> import numpy as np
+            >>> np.random.seed(42)                                                  # Fix the seed for reproduciability
+            >>> from irlc.ex01.inventory_environment import InventoryEnvironment
+            >>> env = InventoryEnvironment()                                        # Create an instance of the environment
+            >>> agent = Agent(env)                                                  # Create an instance of the agent.
+            >>> s0, info0 = env.reset()                                             # Always call reset to start the environment
+            >>> a0 = agent.pi(s0, k=0, info=info0)                                  # Tell the agent to compute action $a_{k=0}$
+            >>> print(f"In state {s0=}, the agent took the action {a0=}")
+    """
+    
+    def __init__(self, env: Env):
+        """Instantiate the Agent class.
+
+        The agent is given the openai gym environment it must interact with. This allows the agent to know what the
+        action and observation space is.
+
+        :param env: The openai gym ``Env`` instance the agent should interact with.
+        """
+        self.env = env   
+
+    def pi(self, s, k : int, info : typing.Optional[dict] =None):
+        r"""Evaluate the Agent's policy (i.e., compute the action the agent want to take) at time step ``k`` in state ``s``.
+        
+        This correspond to the environment being in a state evaluating :math:`x_k`, and the function should compute the next
+        action the agent wish to take:
+                
+        .. math::
+            u_k = \mu_k(x_k)
+        
+        This means that ``s`` = :math:`x_k` and ``k`` = :math:`k =\{0, 1, ...\}`. The function should return an action that lies in the action-space
+        of the environment.
+        
+        The info dictionary:
+            The ``info``-dictionary contains possible extra information returned from the environment, for instance when calling the ``s, info = env.reset()`` function.
+            The main use in this course is in control, where the dictionary contains a value ``info['time_seconds']`` (which corresponds to the simulation time :math:`t` in seconds).
+            
+            We will also use the info dictionary to let the agent know certain actions are not available. This is done by setting the ``info['mask']``-key. 
+            Note that this is only relevant for reinforcement learning, and you should see the documentation/exercises for reinforcement learning for additional details.
+        
+        The default behavior of the agent is to return a random action. An example:
+        
+        .. runblock:: pycon
+        
+            >>> from irlc.pacman.pacman_environment import PacmanEnvironment
+            >>> from irlc import Agent
+            >>> env = PacmanEnvironment()
+            >>> s, info = env.reset()
+            >>> agent = Agent(env)            
+            >>> agent.pi(s, k=0, info=info) # get a random action
+            >>> agent.pi(s, k=0)            # If info is not specified, all actions are assumed permissible.
+                
+
+        :param s: Current state the environment is in.
+        :param timestep: Current time
+        :return: The action the agent want to take in the given state at the given time. By default the agent returns a random action
+        """ 
+        if info is None or 'mask' not in info:
+            return self.env.action_space.sample()
+        else:
+            """ In the case where the actions available in each state differ, openAI deals with that by specifying a 
+            ``mask``-entry in the info-dictionary. The mask can then be passed on to the 
+            env.action_space.sample-function to make sure we don't sample illegal actions. I consider this the most 
+            difficult and annoying thing about openai gym."""
+            if info['mask'].max() > 1:
+                raise Exception("Bad mask!")
+            return self.env.action_space.sample(mask=info['mask']) 
+
+
+    def train(self, s, a, r, sp, done=False, info_s=None, info_sp=None): 
+        r"""Implement this function if the agent has to learn (be trained).
+
+        Note that you only have to implement this function from week 7 onwards -- before that, we are not interested in control methods that learn.
+        
+        The agent takes a number of input arguments. You should imagine that
+         
+        * ``s`` is the current state :math:`x_k``
+        * ``a`` is the action the agent took in state ``s``, i.e. ``a`` :math:`= u_k = \mu_k(x_k)`
+        * ``r`` is the reward the the agent got from that action
+        * ``sp`` (s-plus) is the state the environment then transitioned to, i.e. ``sp`` :math:`= x_{k+1}`
+        * '``done`` tells the agent if the environment has stopped
+        * ``info_s`` is the information-dictionary returned by the environment as it transitioned to ``s``
+        * ``info_sp`` is the information-dictionary returned by the environment as it transitioned to ``sp``.
+          
+        The following example will hopefully clarify it by showing how you would manually call the train-function once:
+          
+        :Example:      
+           
+            .. runblock:: pycon
+
+                >>> from irlc.ex01.inventory_environment import InventoryEnvironment    # import environment
+                >>> from irlc import Agent
+                >>> env = InventoryEnvironment()                                        # Create an instance of the environment
+                >>> agent = Agent(env)                                                  # Create an instance of the agent.
+                >>> s, info_s = env.reset()                                             # s is the current state
+                >>> a = agent.pi(s, k=0, info=info_s)                                   # The agent takes an action
+                >>> sp, r, done, _, info_sp = env.step(a)                               # Environment updates
+                >>> agent.train(s, a, r, sp, done, info_s, info_sp)                     # How the training function is called
+
+        
+        In control and dynamical programming, please recall that the reward is equal to minus the cost.
+        
+        :param s: Current state :math:`x_k`
+        :param a: Action taken :math:`u_k`
+        :param r: Reward obtained by taking action :math:`a_k` in state :math:`x_k`
+        :param sp: The state that the environment transitioned to :math:`{\\bf x}_{k+1}`
+        :param info_s: The information dictionary corresponding to ``s`` returned by ``env.reset`` (when :math:`k=0`) and otherwise ``env.step``.
+        :param info_sp: The information-dictionary corresponding to ``sp`` returned by ``env.step``
+        :param done: Whether environment terminated when transitioning to ``sp``
+        :return: None
+        """
+        pass  
+
+    def __str__(self):
+        """**Optional:** A unique name for this agent. Used for labels when plotting, but can be kept like this."""
+        return super().__str__()
+
+    def extra_stats(self) -> dict:
+        """**Optional:** Implement this function if you wish to record extra information from the ``Agent`` while training.
+
+        You can safely ignore this method as it will only be used for control theory to create nicer plots """
+        return {}
+
+fields = ('time', 'state', 'action', 'reward')
+Trajectory = namedtuple('Trajectory', fields + ("env_info",))
+
+# Experiment using a dataclass.
+@dataclass
+class Stats:
+    episode: int
+    episode_length: int
+    accumulated_reward: float
+
+    total_steps: int
+    trajectory : Trajectory = None
+    agent_stats : dict = None
+
+    @property
+    def average_reward(self):
+        return self.accumulated_reward / self.episode_length
+
+# s = Stats(episode=0, episode_length=5, accumulated_reward=4, total_steps=2, trajectory=Trajectory())
+
+
+def train(env,
+          agent=None,
+          experiment_name=None,
+          num_episodes=1,
+          verbose=True,
+          reset=True, # If True we will call env.reset() upon episode start.
+          max_steps=1e10,
+          max_runs=None,
+          return_trajectory=True, # Return the current trajectories as a list
+          resume_stats=None, # Resume stat collection from last save.
+          log_interval=1, # Only log every log_interval steps. Reduces size of log files.
+          delete_old_experiments=False, # Remove the old experiments folder. Useful while debugging a model (or to conserve disk space)
+          seed=None, # Attempt to set the seed of the random number generator to produce reproducible results.
+          ):
+    """This function implements the main training loop as described in (Her25, Subsection 4.4.4).
+
+    The loop will simulate the interaction between agent `agent` and the environment `env`.
+    The function has a lot of special functionality, so it is useful to consider the common cases. An example:
+
+    >>> stats, _ = train(env, agent, num_episodes=2)
+
+    Simulate interaction for two episodes (i.e. environment terminates two times and is reset).
+    `stats` will be a list of length two containing information from each run
+
+    >>> stats, trajectories = train(env, agent, num_episodes=2, return_Trajectory=True)
+
+    `trajectories` will be a list of length two containing information from the two trajectories.
+
+    >>> stats, _ = train(env, agent, experiment_name='experiments/my_run', num_episodes=2)
+
+    Save `stats`, and trajectories, to a file which can easily be loaded/plotted (see course software for examples of this).
+    The file will be time-stamped so using several calls you can repeat the same experiment (run) many times.
+
+    >>> stats, _ = train(env, agent, experiment_name='experiments/my_run', num_episodes=2, max_runs=10)
+
+    As above, but do not perform more than 10 runs. Useful for repeated experiments.
+
+    :param env: An openai-Gym ``Env`` instance (the environment)
+    :param agent: An ``Agent`` instance
+    :param experiment_name: The outcome of this experiment will be saved in a folder with this name. This will allow you to run multiple (repeated) experiment and visualize the results in a single plot, which is very important in reinforcement learning.
+    :param num_episodes: Number of episodes to simulate
+    :param verbose: Display progress bar
+    :param reset: Call ``env.reset()`` before simulation start. Default is ``True``. This is only useful in very rare cases.
+    :param max_steps: Terminate if this many steps have elapsed (for non-terminating environments)
+    :param max_runs: Maximum number of repeated experiments (requires ``experiment_name``)
+    :param return_trajectory: Return trajectories list (Off by default since it might consume lots of memory)
+    :param resume_stats: Resume stat collection from last run (this requires the ``experiment_name`` variable to be set)
+    :param log_interval: Log stats less frequently than each episode. Useful if you want to run really long experiments.
+    :param delete_old_experiments: If true, old saved experiments will be deleted. This is useful during debugging.
+    :param seed: An integer. The random number generator of the environment will be reset to this seed allowing for reproducible results.
+    :return: A list where each element corresponds to each (started) episode. The elements are dictionaries, and contain the statistics for that episode.
+    """
+
+    from irlc import cache_write
+    from irlc import cache_read
+    saveload_model = False
+    # temporal_policy = None
+    save_stats = True
+    if agent is None:
+        print("[train] No agent was specified. Using irlc.Agent(env) (this agent selects actions at random)")
+        agent = Agent(env)
+
+    if delete_old_experiments and experiment_name is not None and os.path.isdir(experiment_name):
+        shutil.rmtree(experiment_name)
+
+    if experiment_name is not None and max_runs is not None and existing_runs(experiment_name) >= max_runs:
+        stats, recent = load_time_series(experiment_name=experiment_name)
+        if return_trajectory:
+            trajectories = cache_read(recent+"/trajectories.pkl")
+        else:
+            trajectories = []
+        return stats, trajectories
+    stats = []
+    steps = 0
+    ep_start = 0
+    resume_stats = saveload_model if resume_stats is None else resume_stats
+
+    recent = None
+    if resume_stats:
+        stats, recent = load_time_series(experiment_name=experiment_name)
+        if recent is not None:
+            ep_start, steps = stats[-1]['Episode']+1, stats[-1]['Steps']
+
+    trajectories = []
+    # include_metadata = len(inspect.getfullargspec(agent.train).args) >= 7
+    break_outer = False
+
+    with tqdm(total=num_episodes, disable=not verbose, file=sys.stdout, mininterval=int(num_episodes/100) if num_episodes>100 else None) as tq:
+        for i_episode in range(num_episodes): 
+            if break_outer:
+                break
+            info_s = {}
+            if reset or i_episode > 0:
+                if seed is not None:
+                    s, info_s = env.reset(seed=seed)
+                    seed = None
+                else:
+                    s, info_s = env.reset()  
+            elif hasattr(env, "s"):  # This is doing what, exactly? Perhaps save/load of agent?
+                s = env.s
+            elif hasattr(env, 'state'):
+                s = env.state
+            else:
+                s = env.model.s
+            # time = 0
+            reward = []
+            trajectory = Trajectory(time=[], state=[], action=[], reward=[], env_info=[])
+            k = 0 # initial state k.
+            for _ in itertools.count():
+                # policy is always temporal
+                a = agent.pi(s, k, info_s) # if temporal_policy else agent.pi(s)
+                k = k + 1
+                sp, r, terminated, truncated, info_sp = env.step(a)
+                done = terminated or truncated
+
+                if info_sp is not None and 'mask' in info_sp and info_sp['mask'].max() > 1:
+                    print("bad")
+
+                agent.train(s, a, r, sp, done, info_s, info_sp)
+
+                if return_trajectory:
+                    trajectory.time.append(np.asarray(info_s['time_seconds'] if 'time_seconds' in info_s else steps)) #np.asarray(time))
+                    trajectory.state.append(s)
+                    trajectory.action.append(a)
+                    trajectory.reward.append(np.asarray(r))
+                    trajectory.env_info.append(info_s)
+
+                reward.append(r)
+                steps += 1
+                # time += info_sp['dt'] if 'dt' in info_sp else 1
+                # time += 1
+
+                if done or steps >= max_steps:
+                    trajectory.state.append(sp)
+                    trajectory.env_info.append(info_sp)
+                    trajectory.time.append(np.asarray(info_sp['time_seconds'] if 'time_seconds' in info_s else steps))
+                    break_outer = steps >= max_steps
+                    break
+                s = sp 
+                info_s = info_sp
+            if return_trajectory:
+                try:
+                    from irlc.ex04.control_environment import ControlEnvironment
+                    if isinstance(env, ControlEnvironment): # TODO: this is too hacky. States/actions should be lists, and subsequent methods should stack.
+                        trajectory = Trajectory(**{field: np.stack([np.asarray(x_) for x_ in getattr(trajectory, field)]) for field in fields}, env_info=trajectory.env_info)
+                    # else:
+                    #     trajectory = Trajectory(**{field: np.stack([np.asarray(x_) for x_ in getattr(trajectory, field)]) for field in fields}, env_info=trajectory.env_info)
+
+                except Exception as e:
+                    pass
+
+                trajectories.append(trajectory)
+            if (i_episode + 1) % log_interval == 0:
+                stats.append({"Episode": i_episode + ep_start,
+                              "Accumulated Reward": sum(reward),
+                              # "Average Reward": np.mean(reward), # Not sure we need this anymore.
+                              "Length": len(reward),
+                              "Steps": steps, # Useful for deep learning applications. This should be kept, or week 13 will have issues.
+                              **agent.extra_stats()})
+
+            rate = int(num_episodes / 100)
+            if rate > 0 and i_episode % rate == 0:
+                tq.set_postfix(ordered_dict=OrderedDict(list(OrderedDict(stats[-1]).items())[:5])) if len(stats) > 0 else None
+            tq.update()
+
+    sys.stderr.flush()
+
+    if resume_stats and save_stats and recent is not None:
+        os.remove(recent+"/log.txt")
+
+    if experiment_name is not None and save_stats:
+        path = log_time_series(experiment=experiment_name, list_obs=stats)
+        if return_trajectory:
+            cache_write(trajectories, path+"/trajectories.pkl")
+
+        print(f"Training completed. Logging {experiment_name}: '{', '.join( stats[0].keys()) }'")
+
+    for i, t in enumerate(trajectories):
+        from collections import defaultdict
+        nt = defaultdict(lambda: [])
+        if t.env_info is not None and t.env_info[1] is not None and "supersample" in t.env_info[1]:
+            for f in fields:
+                for k, ei in enumerate(t.env_info):
+                    if 'supersample' not in ei:
+                        continue
+                    z = ei['supersample'].__getattribute__(f).T
+                    if k == 0:
+                        pass
+                    else:
+                        z = z[1:]
+                    nt[f].append(z)
+
+            for f in fields:
+                nt[f] = np.concatenate([z for z in nt[f]],axis=0)
+            traj2 = Trajectory(**nt, env_info=[])
+            trajectories[i] = traj2
+
+    # for k, t in enumerate(stats):
+    #     if k < len(trajectories):
+    #         stats[k]['trajectory'] = trajectories[k]
+    # Turn this into a single episodes-list (refactor later)
+    return stats, trajectories
+
+
+if __name__ == "__main__":
+    # Use the trajectories here.
+    from irlc.ex01.inventory_environment import InventoryEnvironment
+    env = InventoryEnvironment(N=10)
+    stats, traj = train(env, Agent(env))
+    print(stats)
+    s = Stats(episode=1, episode_length=2, accumulated_reward=4, total_steps=4, trajectory=None, agent_stats={})
+    print(s)
diff --git a/irlc/ex01/bobs_friend.py b/irlc/ex01/bobs_friend.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d515d8e5e2f8186451fe37b03aa8b83ea7f66ed
--- /dev/null
+++ b/irlc/ex01/bobs_friend.py
@@ -0,0 +1,59 @@
+# This file may not be shared/redistributed without permission. Please read copyright notice in the git repo. If this file contains other copyright notices disregard this text.
+import gymnasium
+import numpy as np
+from gymnasium.spaces.discrete import Discrete
+from irlc.ex01.agent import Agent, train
+
+class BobFriendEnvironment(gymnasium.Env): 
+    def __init__(self, x0=20):
+        self.x0 = x0
+        self.action_space = Discrete(2)     # Possible actions {0, 1} 
+
+    def reset(self):
+        # TODO: 1 lines missing.
+        raise NotImplementedError("Insert your solution and remove this error.")
+        return self.s, {}
+
+    def step(self, a):
+        # TODO: 9 lines missing.
+        raise NotImplementedError("Insert your solution and remove this error.")
+        return s_next, reward, terminated, False, {}
+
+class AlwaysAction_u0(Agent):
+    def pi(self, s, k, info=None):  
+        """This agent should always take action u=0."""
+        # TODO: 1 lines missing.
+        raise NotImplementedError("Implement function body")
+
+class AlwaysAction_u1(Agent):
+    def pi(self, s, k, info=None):  
+        """This agent should always take action u=1."""
+        # TODO: 1 lines missing.
+        raise NotImplementedError("Implement function body")
+
+if __name__ == "__main__":
+    # Part A:
+    env = BobFriendEnvironment()
+    x0, _ = env.reset()
+    print(f"Initial amount of money is x0 = {x0} (should be 20 kroner)")
+    print("Lets put it in the bank, we should end up in state x1=22 and get a reward of 2 kroner")
+    x1, reward, _, _, _ = env.step(0)
+    print("we got", x1, reward)
+    # Since we reset the environment, we should get the same result as before:
+    env.reset()
+    x1, reward, _, _, _ = env.step(0)
+    print("(once more) we got", x1, reward, "(should be the same as before)")
+
+    env.reset()  # We must call reset -- the environment has possibly been changed!
+    print("Lets lend it to our friend -- what happens will now be random")
+    x1, reward, _, _, _ = env.step(1)
+    print("we got", x1, reward)
+
+    # Part B:
+    stats, _ = train(env, AlwaysAction_u0(env), num_episodes=1000)
+    average_u0 = np.mean([stat['Accumulated Reward'] for stat in stats])
+
+    stats, _ = train(env, AlwaysAction_u1(env), num_episodes=1000)
+    average_u1 = np.mean([stat['Accumulated Reward'] for stat in stats])
+    print(f"Average reward while taking action u=0 was {average_u0} (should be 2)")
+    print(f"Average reward while taking action u=1 was {average_u1} (should be 4)")
diff --git a/irlc/ex01/chess.py b/irlc/ex01/chess.py
new file mode 100644
index 0000000000000000000000000000000000000000..935e1fc1c4c40d121bcf249eb00b17e11e618c82
--- /dev/null
+++ b/irlc/ex01/chess.py
@@ -0,0 +1,99 @@
+# This file may not be shared/redistributed without permission. Please read copyright notice in the git repo. If this file contains other copyright notices disregard this text.
+"""This file contains code for the Chess Tournament problem."""
+import numpy as np
+from gymnasium.spaces.discrete import Discrete
+from gymnasium import Env
+
+class ChessTournament(Env):
+    """The ChessTournament gymnasium-environment which simulate a chess tournament.
+
+    In the problem, a chess tournament ends when a player wins two games in a row. The results
+    of each game are -1, 0, 1 corresponding to a loss, draw and win for player 1. See:
+    https://www.youtube.com/watch?v=5UQU1oBpAic
+
+    To implement this, we define the step-function such that one episode of the environment corresponds to playing
+    a chess tournament to completion. Once the environment completes, it returns a reward of +1 if the player won
+    the tournament, and otherwise 0.
+
+    Each step therefore corresponds to playing a single game in the tournament.
+    To implement this, we use a state corresponding to the sequence of games in the tournament:
+
+    >>> self.s = [0, -1, 1, 0, 0, 1]
+
+    In the self.step(action)-function, we ignore the action, simulate the outcome of a single game,
+    and append the outcome to self.s. We then compute whether the tournament has completed, and if so
+    a reward of 1 if we won.
+    """
+
+    def __init__(self, p_draw=3 / 4, p_win=2 / 3):
+        self.action_space = Discrete(1)
+        self.p_draw = p_draw
+        self.p_win = p_win
+        self.s = []  # A chess tournament is a sequence of won/lost games s = [0, -1, 1, 0, ...]
+
+    def reset(self): 
+        """Reset the tournament environment to begin to simulate a new tournament.
+
+        After each episode is complete, this function will reset :python:`self.s` and return the current state s and an empty dictionary.
+        :return:
+            - s - The initial state (what is it?)
+            - info - An empty dictionary, ``{}``
+        """
+        # TODO: 1 lines missing.
+        raise NotImplementedError("Implement function body")
+        return self.s, {}
+
+    def step(self, action):
+        """Play a single game in the current tournament
+
+        The variable action is required by gymnasium but it is not used since no (player) actions occur in this problem.
+
+        The step-method should update `self.state` to be the next (new) state, compute the reward, and determine whether
+        the environment has terminated (:python:`done`).
+
+        :param action: This input is required by gymnasium but it is not used in this case.
+        :return: A tuple of the form :python:`(new_state, reward, done, False, {})`
+        """
+        game_outcome = None # should be -1, 0, or 1 depending on outcome of single game.
+        ## TODO: Oy veh, the following 7 lines below have been permuted. Uncomment, rearrange to the correct order and remove the error.
+        #-------------------------------------------------------------------------------------------------------------------------------
+        #     else:
+        # else:
+        #         game_outcome = 1
+        #     if np.random.rand() < self.p_win:
+        #         game_outcome = -1 
+        #     game_outcome = 0
+        # if np.random.rand() < self.p_draw: 
+        raise NotImplementedError("Compute game_outcome here")
+        self.s.append(game_outcome)
+
+        #done = True if the tournament has ended otherwise false. Compute using s.
+        # TODO: 1 lines missing.
+        raise NotImplementedError("Compute 'done', whether the tournament has ended.")
+        # r = ... . Compute reward. Let r=1 if we won the tournament otherwise 0.
+        # TODO: 1 lines missing.
+        raise NotImplementedError("Compute the reward 'r' here.")
+        return self.s, r, done, False, {}
+
+def main():
+    """The main method of the chess-game problem.
+
+    This function will simulate T tournament games and estimate average win probability for player 1 as p_win (answer to riddle) and also
+    the average length. Note the later should be a 1-liner, but would require non-trivial computations to solve
+    analytically. Please see the :class:`gymnasium.Env` class for additional details.
+    """
+    T = 5000
+    from irlc import train, Agent
+    env = ChessTournament()
+    # Compute stats using the train function. Simulate the tournament for a total of T=10'000 episodes.
+    # TODO: 1 lines missing.
+    raise NotImplementedError("Compute stats here using train(env, ...). Use num_episodes.")
+    p_win = np.mean([st['Accumulated Reward'] for st in stats])
+    avg_length = np.mean([st['Length'] for st in stats])
+
+    print("Agent: Estimated chance I won the tournament: ", p_win)  
+    print("Agent: Average tournament length", avg_length)  
+
+
+if __name__ == "__main__":
+    main()
diff --git a/irlc/ex01/inventory_environment.py b/irlc/ex01/inventory_environment.py
new file mode 100644
index 0000000000000000000000000000000000000000..b4fb9b0d7b81fbf071dfa19057a056c4ae4eaf83
--- /dev/null
+++ b/irlc/ex01/inventory_environment.py
@@ -0,0 +1,71 @@
+# This file may not be shared/redistributed without permission. Please read copyright notice in the git repo. If this file contains other copyright notices disregard this text.
+import numpy as np
+from gymnasium.spaces.discrete import Discrete
+from gymnasium import Env
+from irlc.ex01.agent import Agent, train
+
+class InventoryEnvironment(Env): 
+    def __init__(self, N=2):
+        self.N = N                               # planning horizon
+        self.action_space      = Discrete(3)     # Possible actions {0, 1, 2}
+        self.observation_space = Discrete(3)     # Possible observations {0, 1, 2}
+
+    def reset(self):
+        self.s = 0                               # reset initial state x0=0
+        self.k = 0                               # reset time step k=0
+        return self.s, {}                        # Return the state we reset to (and an empty dict)
+
+    def step(self, a):
+        w = np.random.choice(3, p=(.1, .7, .2))    # Generate random disturbance
+        # TODO: 5 lines missing.
+        raise NotImplementedError("Insert your solution and remove this error.")
+        return s_next, reward, terminated, False, {}  # return transition information  
+
+class RandomAgent(Agent): 
+    def pi(self, s, k, info=None): 
+        """ Return action to take in state s at time step k """
+        # TODO: 1 lines missing.
+        raise NotImplementedError("Implement function body")
+
+
+def simplified_train(env: Env, agent: Agent) -> float: 
+    s, _ = env.reset()
+    J = 0  # Accumulated reward for this rollout
+    for k in range(1000):
+        ## TODO: Oy veh, the following 7 lines below have been permuted. Uncomment, rearrange to the correct order and remove the error.
+        #-------------------------------------------------------------------------------------------------------------------------------
+        # if terminated or truncated:
+        # sp, r, terminated, truncated, metadata = env.step(a)
+        # a = agent.pi(s, k) 
+        # s = sp
+        # J += r
+        # agent.train(s, a, sp, r, terminated)
+        #     break 
+        raise NotImplementedError("Remove this exception after the above lines have been uncommented and rearranged.")
+    return J 
+
+def run_inventory():
+    env = InventoryEnvironment() 
+    agent = RandomAgent(env)
+    stats, _ = train(env,agent,num_episodes=1,verbose=False)  # Perform one rollout.
+    print("Accumulated reward of first episode", stats[0]['Accumulated Reward']) 
+    # I recommend inspecting 'stats' in a debugger; why do you think it is a list of length 1?
+
+    stats, _ = train(env, agent, num_episodes=1000,verbose=False)  # do 1000 rollouts 
+    avg_reward = np.mean([stat['Accumulated Reward'] for stat in stats])
+    print("[RandomAgent class] Average cost of random policy J_pi_random(0)=", -avg_reward) 
+    # Try to inspect stats again in a debugger here. How long is the list now?
+
+    stats, _ = train(env, Agent(env), num_episodes=1000,verbose=False)  # Perform 1000 rollouts using Agent class 
+    avg_reward = np.mean([stat['Accumulated Reward'] for stat in stats])
+    print("[Agent class] Average cost of random policy J_pi_random(0)=", -avg_reward)  
+
+    """ Second part: Using the simplified training method. I.e. do not use train() below.
+     You can find some pretty strong hints about what goes on in simplified_train in the lecture slides for today. """
+    avg_reward_simplified_train = np.mean( [simplified_train(env, agent) for i in range(1000)]) 
+    print("[simplified train] Average cost of random policy J_pi_random(0) =", -avg_reward_simplified_train)  
+
+
+
+if __name__ == "__main__":
+    run_inventory()
diff --git a/irlc/ex01/pacman_hardcoded.py b/irlc/ex01/pacman_hardcoded.py
new file mode 100644
index 0000000000000000000000000000000000000000..62547565232907e67c339e90463d1c7a9cd6f121
--- /dev/null
+++ b/irlc/ex01/pacman_hardcoded.py
@@ -0,0 +1,60 @@
+# This file may not be shared/redistributed without permission. Please read copyright notice in the git repo. If this file contains other copyright notices disregard this text.
+from irlc.pacman.pacman_environment import PacmanEnvironment
+from irlc import Agent, train, savepdf
+
+
+# Maze layouts can be specified using a string.
+layout = """
+%%%%%%%%%%
+%P.......%
+%.%%%%%%.%
+%.%    %.%
+%.%    %.%
+%.%    %.%
+%.%    %.%
+%.%%%%%%.%
+%........%
+%%%%%%%%%%
+"""
+
+# This is our first agent. Note it inherits from the Agent class. Use <ctrl>+click in pycharm to navigate to code definitions --
+# this is a very useful habbit when you work with other peoples code in general, and object-oriented code in particular.
+class GoAroundAgent(Agent):
+    def pi(self, x, k, info=None): 
+        """ Collect all dots in the maze in the smallest amount of time.
+        This function should return an action, check the output of the code below to see what actions you can potentially
+        return.
+        Remember Pacman only have to solve this single maze, so don't make the function general.
+
+        Hints:
+            - Insert a breakpoint in the function. Try to write self.env and self.env.action_space.actions in the interpreter. Where did self.env get set?
+            - Remember that k is the current step number.
+            - Ignore the info dictionary; you can probably also ignore the state x.
+            - The function should return a string (the actions are strings such as 'North')
+        """
+        # TODO: 7 lines missing.
+        raise NotImplementedError("Implement function body")
+        return 'West'
+
+if __name__ == "__main__":
+    # Create an environment with the given layout. animate_movement is just for a nicer visualization.
+    env = PacmanEnvironment(layout_str=layout, render_mode='human')
+    # This creates a visualization (Note this makes the environment slower) which can help us see what Pacman does
+    # This create the GoAroundAgent-instance
+    agent = GoAroundAgent(env)
+    # Uncomment the following line to input actions instead of the agent using the keyboard:
+    # env, agent = interactive(env, agent)
+    s, info = env.reset() # Reset (and start) the environment
+
+    savepdf("pacman_roundabout.pdf", env=env) # Saves a snapshot of the start layout
+    # The next two lines display two ways to get the available actions. The 'canonical' way using the
+    # env.action_space, and a way particular to Pacman by using the s.A() function on the state.
+    # You can read more about the functions in the state in project 1.
+    # print("Available actions at start:", env.action_space.actions) # This will list the available actions. 
+    print("Alternative way of getting actions:", s.A())  # See also project description
+
+    # Simulate the agent for one episode
+    stats, _ = train(env, agent, num_episodes=1)
+    # Print your obtained score.
+    print("Your obtained score was", stats[0]['Accumulated Reward'])
+    env.close()  # When working with visualizations, call env.close() to close windows it may have opened. "
diff --git a/irlc/exam/exam2023spring/__init__.py b/irlc/exam/exam2023spring/__init__.py
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..a56057c84d0ceac54aab1d40ba0f370c77fe10be 100644
--- a/irlc/exam/exam2023spring/__init__.py
+++ b/irlc/exam/exam2023spring/__init__.py
@@ -0,0 +1 @@
+# This file may not be shared/redistributed without permission. Please read copyright notice in the git repo. If this file contains other copyright notices disregard this text.
diff --git a/irlc/exam/exam2023spring/exam2023spring.pdf b/irlc/exam/exam2023spring/exam2023spring.pdf
deleted file mode 100644
index bdd6de3cfe5d79986fff304f59484f44e1dbd197..0000000000000000000000000000000000000000
Binary files a/irlc/exam/exam2023spring/exam2023spring.pdf and /dev/null differ
diff --git a/irlc/exam/exam2023spring/exam2023spring_problems_nosol.zip b/irlc/exam/exam2023spring/exam2023spring_problems_nosol.zip
deleted file mode 100644
index f2dc8fe47613b69a5fa8915b716f90f8ec51c988..0000000000000000000000000000000000000000
Binary files a/irlc/exam/exam2023spring/exam2023spring_problems_nosol.zip and /dev/null differ
diff --git a/irlc/exam/exam2023spring/readme.md b/irlc/exam/exam2023spring/readme.md
new file mode 100644
index 0000000000000000000000000000000000000000..c041c5216f5a12754b844c5d316e1d0e835ec09a
--- /dev/null
+++ b/irlc/exam/exam2023spring/readme.md
@@ -0,0 +1,2 @@
+This directory is purposefully left empty. During the exam, you will be given a `.zip` file with the content of this directory. 
+Replace this directory with the corresponding directory from the `.zip` file to begin working on the exam. 
diff --git a/irlc/exam/exam2024spring/__init__.py b/irlc/exam/exam2024spring/__init__.py
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..a56057c84d0ceac54aab1d40ba0f370c77fe10be 100644
--- a/irlc/exam/exam2024spring/__init__.py
+++ b/irlc/exam/exam2024spring/__init__.py
@@ -0,0 +1 @@
+# This file may not be shared/redistributed without permission. Please read copyright notice in the git repo. If this file contains other copyright notices disregard this text.
diff --git a/irlc/exam/exam2024spring/readme.md b/irlc/exam/exam2024spring/readme.md
new file mode 100644
index 0000000000000000000000000000000000000000..c041c5216f5a12754b844c5d316e1d0e835ec09a
--- /dev/null
+++ b/irlc/exam/exam2024spring/readme.md
@@ -0,0 +1,2 @@
+This directory is purposefully left empty. During the exam, you will be given a `.zip` file with the content of this directory. 
+Replace this directory with the corresponding directory from the `.zip` file to begin working on the exam. 
diff --git a/irlc/exam/midterm2023a/__init__.py b/irlc/exam/midterm2023a/__init__.py
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..a56057c84d0ceac54aab1d40ba0f370c77fe10be 100644
--- a/irlc/exam/midterm2023a/__init__.py
+++ b/irlc/exam/midterm2023a/__init__.py
@@ -0,0 +1 @@
+# This file may not be shared/redistributed without permission. Please read copyright notice in the git repo. If this file contains other copyright notices disregard this text.
diff --git a/irlc/exam/midterm2023a/midterm2023a.pdf b/irlc/exam/midterm2023a/midterm2023a.pdf
deleted file mode 100644
index 1f744703e6e059a56a52385921eac20ac1c407f4..0000000000000000000000000000000000000000
Binary files a/irlc/exam/midterm2023a/midterm2023a.pdf and /dev/null differ
diff --git a/irlc/exam/midterm2023a/midterm2023a_problems_nosol.zip b/irlc/exam/midterm2023a/midterm2023a_problems_nosol.zip
deleted file mode 100644
index 32b50ea36fd9ef796ce38b983407b626e6ff97ca..0000000000000000000000000000000000000000
Binary files a/irlc/exam/midterm2023a/midterm2023a_problems_nosol.zip and /dev/null differ
diff --git a/irlc/exam/midterm2023b/__init__.py b/irlc/exam/midterm2023b/__init__.py
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..a56057c84d0ceac54aab1d40ba0f370c77fe10be 100644
--- a/irlc/exam/midterm2023b/__init__.py
+++ b/irlc/exam/midterm2023b/__init__.py
@@ -0,0 +1 @@
+# This file may not be shared/redistributed without permission. Please read copyright notice in the git repo. If this file contains other copyright notices disregard this text.
diff --git a/irlc/exam/midterm2023b/midterm2023b.pdf b/irlc/exam/midterm2023b/midterm2023b.pdf
deleted file mode 100644
index 8285b441e012d3dbb3ded27452268acf50c25534..0000000000000000000000000000000000000000
Binary files a/irlc/exam/midterm2023b/midterm2023b.pdf and /dev/null differ
diff --git a/irlc/exam/midterm2023b/midterm2023b_problems_nosol.zip b/irlc/exam/midterm2023b/midterm2023b_problems_nosol.zip
deleted file mode 100644
index 63d3d8a4589ecc9d862f1ad4b8bb5227355087fb..0000000000000000000000000000000000000000
Binary files a/irlc/exam/midterm2023b/midterm2023b_problems_nosol.zip and /dev/null differ
diff --git a/irlc/gridworld/gridworld_environments.py b/irlc/gridworld/gridworld_environments.py
index 6d72a4604efb618601f8f6fb51ff77a863be92b5..ec7497a9757fdc781ef55337b3f965ea055fffbf 100644
--- a/irlc/gridworld/gridworld_environments.py
+++ b/irlc/gridworld/gridworld_environments.py
@@ -130,7 +130,7 @@ class GridworldEnvironment(MDP2GymEnv):
             from irlc.gridworld.gridworld_graphics_display import GraphicsGridworldDisplay
             self.display_pygame = GraphicsGridworldDisplay(self.mdp, size=int(150 * self.zoom), frames_per_second=self.frames_per_second) # last item is grid size
 
-        agent = self.agent
+        agent = self.unwrapped.agent
         label = None
         method_label = agent.method if hasattr(agent, 'method') else ''
         if label is None and len(method_label) > 0:
diff --git a/irlc/project0/fruit_project_grade.py b/irlc/project0/fruit_project_grade.py
index 09f167b5c8a0f91562f2669a6894fdd19f0db404..45effc9d1199015fbb7986c0b3f76d7d0966054e 100644
--- a/irlc/project0/fruit_project_grade.py
+++ b/irlc/project0/fruit_project_grade.py
@@ -1,4 +1,4 @@
 # irlc/project0/fruit_project_tests.py
 ''' WARNING: Modifying, decompiling or otherwise tampering with this script, it's data or the resulting .token file will be investigated as a cheating attempt. '''
 import bz2, base64
-exec(bz2.decompress(base64.b64decode('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')))
\ No newline at end of file
+exec(bz2.decompress(base64.b64decode('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')))
\ No newline at end of file
diff --git a/irlc/project0/unitgrade_data/AdditionQuestion.pkl b/irlc/project0/unitgrade_data/AdditionQuestion.pkl
index 0c4041c8e0e84dd5d88fbdef9bb42dfe5acb86c1..fe9c2a23f2af8dc94ac2bd4bf81d5e54a9b68160 100644
Binary files a/irlc/project0/unitgrade_data/AdditionQuestion.pkl and b/irlc/project0/unitgrade_data/AdditionQuestion.pkl differ
diff --git a/irlc/project0/unitgrade_data/BasicClass.pkl b/irlc/project0/unitgrade_data/BasicClass.pkl
index 92432f3a7881a8671667fa274e3f2ad4ce75f0a7..47ed674dfcb1e6f259cee38efda6aaac9ceb15e8 100644
Binary files a/irlc/project0/unitgrade_data/BasicClass.pkl and b/irlc/project0/unitgrade_data/BasicClass.pkl differ
diff --git a/irlc/project0/unitgrade_data/MeanOfDie.pkl b/irlc/project0/unitgrade_data/MeanOfDie.pkl
index 1fc660ef2bdeb1a5a38c2b4da18a0e5cbe3e314f..da4fbd8a3572fb97700917d214f1198c6c5f3434 100644
Binary files a/irlc/project0/unitgrade_data/MeanOfDie.pkl and b/irlc/project0/unitgrade_data/MeanOfDie.pkl differ
diff --git a/irlc/project0/unitgrade_data/MisterfyQuestion.pkl b/irlc/project0/unitgrade_data/MisterfyQuestion.pkl
index 2fd6e50ff8e35454d3b2f7706f33086fc43d468b..3c7b548715ac22b52e6f066bc7131de0f81ff4c8 100644
Binary files a/irlc/project0/unitgrade_data/MisterfyQuestion.pkl and b/irlc/project0/unitgrade_data/MisterfyQuestion.pkl differ
diff --git a/irlc/project1/Latex/02465project1_handin.tex b/irlc/project1/Latex/02465project1_handin.tex
new file mode 100644
index 0000000000000000000000000000000000000000..f59e1d27e2cf427513a83618a9f3df9d071bd70b
--- /dev/null
+++ b/irlc/project1/Latex/02465project1_handin.tex
@@ -0,0 +1,107 @@
+\documentclass[12pt,twoside]{article}
+%\usepackage[table]{xcolor} % important to avoid options clash.
+%\input{02465shared_preamble}
+%\usepackage{cleveref}
+\usepackage{url}
+\usepackage{graphics}
+\usepackage{multicol}
+\usepackage{rotate}
+\usepackage{rotating}
+\usepackage{booktabs}
+\usepackage{hyperref}
+\usepackage{pifont}
+\usepackage{latexsym}
+\usepackage[english]{babel}
+\usepackage{epstopdf}
+\usepackage{etoolbox}
+\usepackage{amsmath}
+\usepackage{amssymb}
+\usepackage{multirow,epstopdf}
+\usepackage{fancyhdr}
+\usepackage{booktabs}
+\usepackage{xcolor}
+\newcommand\redt[1]{ {\textcolor[rgb]{0.60, 0.00, 0.00}{\textbf{ #1} } } }
+
+
+\newcommand{\m}[1]{\boldsymbol{ #1}}
+\newcommand{\yoursolution}{ \redt{(your solution here) } } 
+
+
+
+\title{ Report 1 hand-in }
+\date{ \today }
+\author{Alice (\texttt{s000001})\and  Bob (\texttt{s000002})\and Clara (\texttt{s000003}) } 
+
+\begin{document}
+\maketitle
+
+\begin{table}[ht!]
+\caption{Attribution table. Feel free to add/remove rows and columns}
+\begin{tabular}{llll}
+\toprule
+                                                        & Alice   & Bob    & Clara   \\
+\midrule
+ 1: A basic blaster-business                            & 0-100\%  & 0-100\% & 0-100\%  \\
+ 2: Warmup                                              & 0-100\%  & 0-100\% & 0-100\%  \\
+ 3: Manually computing $J_{N-1}$                        & 0-100\%  & 0-100\% & 0-100\%  \\
+ 4: Compute optimal policy and value function           & 0-100\%  & 0-100\% & 0-100\%  \\
+ 5: Kiosk2                                              & 0-100\%  & 0-100\% & 0-100\%  \\
+ 6: Explaining the policy                               & 0-100\%  & 0-100\% & 0-100\%  \\
+ 7: Policy explanation continued                        & 0-100\%  & 0-100\% & 0-100\%  \\
+ 8: Go east                                             & 0-100\%  & 0-100\% & 0-100\%  \\
+ 9: Describe the go-east problem                        & 0-100\%  & 0-100\% & 0-100\%  \\
+ 10: Predict consequence of actions                     & 0-100\%  & 0-100\% & 0-100\%  \\
+ 11: Possible future states                             & 0-100\%  & 0-100\% & 0-100\%  \\
+ 12: Shortest path                                      & 0-100\%  & 0-100\% & 0-100\%  \\
+ 13: Predict consequence of actions with one ghost      & 0-100\%  & 0-100\% & 0-100\%  \\
+ 14: Possible future states with one ghost              & 0-100\%  & 0-100\% & 0-100\%  \\
+ 15: Optimal one-ghost planning                         & 0-100\%  & 0-100\% & 0-100\%  \\
+ 16: Predict consequence of actions with several ghosts & 0-100\%  & 0-100\% & 0-100\%  \\
+ 17: Future states                                      & 0-100\%  & 0-100\% & 0-100\%  \\
+ 18: Optimal planning                                   & 0-100\%  & 0-100\% & 0-100\%  \\
+\bottomrule
+\end{tabular}
+\end{table}
+
+%\paragraph{Statement about collaboration:}
+%Please edit this section to reflect how you have used external resources. The following statement will in most cases suffice: 
+%\emph{The code in the irls/project1 directory is entirely}
+
+%\paragraph{Main report:}
+Headings have been inserted in the document for readability. You only have to edit the part which says \yoursolution. 
+
+\section{The kiosk (\texttt{kiosk.py})}
+\subsubsection*{{\color{red}Problem 1:  A basic blaster-business}}
+
+\yoursolution 	
+\redt{To get you started: \begin{align}
+	N & = 14 \\
+	\mbox{for $k=0,\dots,N$: }\quad	\mathcal{S}_k & = \dots \\
+	\mbox{for $k=0,\dots,N-1$: }\quad \mathcal{A}_k(x_k) & = \dots \\
+	 & \vdots 
+\end{align} }
+
+\subsubsection*{{\color{red}Problem 3:  Manually computing $J_{N-1}$}}
+		
+	\yoursolution 	
+	$$
+	J_{N-1}(20)  = ...
+	$$
+	
+\subsubsection*{{\color{red}Problem 6:  Explaining the policy}}
+
+					The first policy... this can be explained by noting ... \yoursolution 
+
+\subsubsection*{{\color{red}Problem 7:  Policy explanation continued}}
+	
+	$$\mu_{N-1}(0) = ...$$
+\yoursolution 		
+
+\section{Avoid the droid (\texttt{pacman.py)}} 
+\subsubsection*{{\color{red}Problem 9:  Describe the go-east problem}}
+	
+		The environment is an example of a .... \\		
+		The controller is an example of a ...
+		\yoursolution 	
+	
+\end{document}
\ No newline at end of file
diff --git a/irlc/project1/Latex/figures/kiosk1.pdf b/irlc/project1/Latex/figures/kiosk1.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..54c179fa1703c83e77398a3f6382d3e685fc8fd9
Binary files /dev/null and b/irlc/project1/Latex/figures/kiosk1.pdf differ
diff --git a/irlc/project1/Latex/figures/kiosk2.pdf b/irlc/project1/Latex/figures/kiosk2.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..07dd964485a357336d64c2393ce3fc97c8af1e14
Binary files /dev/null and b/irlc/project1/Latex/figures/kiosk2.pdf differ
diff --git a/irlc/project1/Latex/figures/your_answer.pdf b/irlc/project1/Latex/figures/your_answer.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..d8c092974e20aaaf1165958a53bdce3a2ebdbf8f
Binary files /dev/null and b/irlc/project1/Latex/figures/your_answer.pdf differ
diff --git a/irlc/project1/__init__.py b/irlc/project1/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a56057c84d0ceac54aab1d40ba0f370c77fe10be
--- /dev/null
+++ b/irlc/project1/__init__.py
@@ -0,0 +1 @@
+# This file may not be shared/redistributed without permission. Please read copyright notice in the git repo. If this file contains other copyright notices disregard this text.
diff --git a/irlc/project1/kiosk.py b/irlc/project1/kiosk.py
new file mode 100644
index 0000000000000000000000000000000000000000..ef5136b474551ef8f8d156bd5e8d5df7b32975a6
--- /dev/null
+++ b/irlc/project1/kiosk.py
@@ -0,0 +1,70 @@
+# This file may not be shared/redistributed without permission. Please read copyright notice in the git repo. If this file contains other copyright notices disregard this text.
+"""
+This project resembles the Inventory-control problem discussed in (Her25, Subsection 5.1.2) but with more complicated rules.
+If you are stuck, the inventory-control problem will be a good place to start.
+
+I recommend to use the DP_stochastic function (as we did with the inventory-control example). This means
+your main problem is to build appropriate DPModel-classes to represent the different problems.
+
+References:
+  [Her25] Tue Herlau. Sequential decision making. (Freely available online), 2025.
+"""
+from irlc.ex02.dp_model import DPModel
+from irlc.ex02.dp import DP_stochastic
+import matplotlib.pyplot as plt
+from scipy.stats import binom
+from irlc import savepdf
+import numpy as np
+
+def plot_policy(pi, title, pdf):
+    """ Helper function to plot the policy functions pi, as generated by the DP_stochastic function. This function
+    can be used to visualize which actions are taken in which state (y-axis) at which time step (x-axis). """
+    N = len(pi)
+    W = max(pi[0].keys())
+    A = np.zeros((W, N))
+    for i in range(W):
+        for j in range(N):
+            A[i, j] = pi[j][i]
+    plt.imshow(A)
+    plt.title(title)
+    savepdf(pdf)
+    plt.show()
+
+# TODO: 51 lines missing.
+raise NotImplementedError("Insert your solution and remove this error.")
+
+def warmup_states(): 
+    # TODO: 1 lines missing.
+    raise NotImplementedError("return state set")
+
+def warmup_actions(): 
+    # TODO: 1 lines missing.
+    raise NotImplementedError("return action set")
+
+def solve_kiosk_1(): 
+    # TODO: 1 lines missing.
+    raise NotImplementedError("Return cost and policy here (same format as DP_stochastic)")
+
+def solve_kiosk_2(): 
+    # TODO: 1 lines missing.
+    raise NotImplementedError("Return cost and policy here (same format as DP_stochastic)")
+
+
+def main():
+    # Problem 14
+    print("Available states S_0:", warmup_states())
+    print("Available actions A_0(x_0):", warmup_actions())
+
+    J, pi = solve_kiosk_1() # Problem 16
+    print("Kiosk1: Expected profits: ", -J[0][0], " imperial credits")
+    plot_policy(pi, "Kiosk1", "Latex/figures/kiosk1")
+    plt.show()
+
+    J, pi = solve_kiosk_2() # Problem 17
+    print("Kiosk 2: Expected profits: ", -J[0][0], " imperial credits")
+    plot_policy(pi, "Kiosk2", "Latex/figures/kiosk2")
+    plt.show()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/irlc/project1/pacman.py b/irlc/project1/pacman.py
new file mode 100644
index 0000000000000000000000000000000000000000..9fb9dd9c53ac962e134cfd4a31024029cad507eb
--- /dev/null
+++ b/irlc/project1/pacman.py
@@ -0,0 +1,169 @@
+# This file may not be shared/redistributed without permission. Please read copyright notice in the git repo. If this file contains other copyright notices disregard this text.
+from collections import defaultdict
+from irlc import train
+from irlc.ex02.dp_model import DPModel
+from irlc.ex02.dp import DP_stochastic
+from irlc.ex02.dp_agent import DynamicalProgrammingAgent
+from irlc.pacman.pacman_environment import PacmanEnvironment
+from irlc.pacman.gamestate import GameState
+
+east = """ 
+%%%%%%%%
+% P   .%
+%%%%%%%% """ 
+
+east2 = """
+%%%%%%%%
+%    P.%
+%%%%%%%% """
+
+SS2tiny = """
+%%%%%%
+%.P  %
+% GG.%
+%%%%%%
+"""
+
+SS0tiny = """
+%%%%%%
+%.P  %
+%   .%
+%%%%%%
+"""
+
+SS1tiny = """
+%%%%%%
+%.P  %
+%  G.%
+%%%%%%
+"""
+
+datadiscs = """
+%%%%%%%
+%    .%
+%.P%% %
+%.   .%
+%%%%%%%
+"""
+
+# TODO: 30 lines missing.
+raise NotImplementedError("Put your own code here")
+
+def p_next(x : GameState, u: str): 
+    """ Given the agent is in GameState x and takes action u, the game will transition to a new state xp.
+    The state xp will be random when there are ghosts. This function should return a dictionary of the form
+
+    {..., xp: p, ...}
+
+    of all possible next states xp and their probability -- you need to compute this probability.
+
+    Hints:
+        * In the above, xp should be a GameState, and p will be a float. These are generated using the functions in the GameState x.
+        * Start simple (zero ghosts). Then make it work with one ghosts, and then finally with any number of ghosts.
+        * Remember the ghosts move at random. I.e. if a ghost has 3 available actions, it will choose one with probability 1/3
+        * The slightly tricky part is that when there are multiple ghosts, different actions by the individual ghosts may lead to the same final state
+        * Check the probabilities sum to 1. This will be your main way of debugging your code and catching issues relating to the previous point.
+    """
+    # TODO: 8 lines missing.
+    raise NotImplementedError("Return a dictionary {.., xp: p, ..} where xp is a possible next state and p the probability")
+    return states
+
+
+def go_east(map): 
+    """ Given a map-string map (see examples in the top of this file) that can be solved by only going east, this will return
+    a list of states Pacman will traverse. The list it returns should therefore be of the form:
+
+    [s0, s1, s2, ..., sn]
+
+    where each sk is a GameState object, the first element s0 is the start-configuration (corresponding to that in the Map),
+    and the last configuration sn is a won GameState obtained by going east.
+
+    Note this function should work independently of the number of required east-actions.
+
+    Hints:
+        * Use the GymPacmanEnvironment class. The report description will contain information about how to set it up, as will pacman_demo.py
+        * Use this environment to get the first GameState, then use the recommended functions to go east
+    """
+    # TODO: 5 lines missing.
+    raise NotImplementedError("Return the list of states pacman will traverse if he goes east until he wins the map")
+    return states
+
+def get_future_states(x, N): 
+    # TODO: 4 lines missing.
+    raise NotImplementedError("return a list-of-list of future states [S_0, ... ,S_N]. Each S_k is a state space, i.e. a list of GameState objects.")
+    return state_spaces
+
+def win_probability(map, N=10): 
+    """ Assuming you get a reward of -1 on wining (and otherwise zero), the win probability is -J_pi(x_0). """
+    # TODO: 5 lines missing.
+    raise NotImplementedError("Return the chance of winning the given map within N steps or less.")
+    return win_probability
+
+def shortest_path(map, N=10): 
+    """ If each move has a cost of 1, the shortest path is the path with the lowest cost.
+    The actions should be the list of actions taken.
+    The states should be a list of states the agent visit. The first should be the initial state and the last
+    should be the won state. """
+    # TODO: 4 lines missing.
+    raise NotImplementedError("Return the cost of the shortest path, the list of actions taken, and the list of states.")
+    return actions, states
+
+
+def no_ghosts():
+    # Check the pacman_demo.py file for help on the GameState class and how to get started.
+    # This function contains examples of calling your functions. However, you should use unitgrade to verify correctness.
+
+    ## Problem 1: Lets try to go East. Run this code to see if the states you return looks sensible.
+    states = go_east(east)
+    for s in states:
+        print(str(s))
+
+    ## Problem 3: try the p_next function for a few empty environments. Does the result look sensible?
+    x, _ = PacmanEnvironment(layout_str=east).reset()
+    action = x.A()[0]
+    print(f"Transitions when taking action {action} in map: 'east'")
+    print(x)
+    print(p_next(x, action))  # use str(state) to get a nicer representation.
+
+    print(f"Transitions when taking action {action} in map: 'east2'")
+    x, _ = PacmanEnvironment(layout_str=east2).reset()
+    print(x)
+    print(p_next(x, action))
+
+    ## Problem 4
+    print(f"Checking states space S_1 for k=1 in SS0tiny:")
+    x, _ = PacmanEnvironment(layout_str=SS0tiny).reset()
+    states = get_future_states(x, N=10)
+    for s in states[1]: # Print all elements in S_1.
+        print(s)
+    print("States at time k=10, |S_10| =", len(states[10]))
+
+    ## Problem 6
+    N = 20  # Planning horizon
+    action, states = shortest_path(east, N)
+    print("east: Optimal action sequence:", action)
+
+    action, states = shortest_path(datadiscs, N)
+    print("datadiscs: Optimal action sequence:", action)
+
+    action, states = shortest_path(SS0tiny, N)
+    print("SS0tiny: Optimal action sequence:", action)
+
+
+def one_ghost():
+    # Win probability when planning using a single ghost. Notice this tends to increase with planning depth
+    wp = []
+    for n in range(10):
+        wp.append(win_probability(SS1tiny, N=n))
+    print(wp)
+    print("One ghost:", win_probability(SS1tiny, N=12))
+
+
+def two_ghosts():
+    # Win probability when planning using two ghosts
+    print("Two ghosts:", win_probability(SS2tiny, N=12))
+
+if __name__ == "__main__":
+    no_ghosts()
+    one_ghost()
+    two_ghosts()
diff --git a/irlc/project1/pacman_demo1.py b/irlc/project1/pacman_demo1.py
new file mode 100644
index 0000000000000000000000000000000000000000..bf74e07b095507c77acd59521cd892a40b11d1ac
--- /dev/null
+++ b/irlc/project1/pacman_demo1.py
@@ -0,0 +1,53 @@
+# This file may not be shared/redistributed without permission. Please read copyright notice in the git repo. If this file contains other copyright notices disregard this text.
+from irlc.pacman.pacman_environment import PacmanEnvironment
+from irlc.project1.pacman import east, datadiscs, SS1tiny, SS2tiny
+from irlc import interactive, savepdf, Agent, train
+import matplotlib
+matplotlib.use('qtagg')
+
+count = """
+%%%%
+%P %
+%..%
+%%%%
+"""
+
+
+if __name__ == "__main__":
+    # Example interaction with an environment:
+    # Instantiate the map 'east' and get a GameState instance: 
+    env = PacmanEnvironment(layout_str=east, render_mode='human')
+    x, info = env.reset() # x is a irlc.pacman.gamestate.GameState object. See the online documentation for more examples.
+    print("Start configuration of board:")
+    print(x)
+    env.close() # If you use render_mode = 'human', I recommend you use env.close() at the end of the code to free up graphics resources.
+    # The GameState object `x` has a handful of useful functions. The important ones are:
+    # x.A()       # Action space
+    # x.f(action) # State resulting in taking action 'action' in state 'x'
+    # x.players() # Number of agents on board (at least 1)
+    # x.player()  # Whose turn it is (player = 0 is us)
+    # x.is_won()   # True if we have won
+    # x.is_lost()  # True if we have lost
+    # You can check if two GameState objects x1 and x2 are the same by simply doing x1 == x2. 
+    # There are other functions in the GameState class, but I advise against using them.
+    from irlc.pacman.pacman_environment import PacmanEnvironment, datadiscs
+    env = PacmanEnvironment(layout_str=datadiscs, render_mode='human')
+    s, _ = env.reset()
+
+    savepdf('pacman_east', env=env)
+    env.close()
+
+    env = PacmanEnvironment(layout_str=datadiscs, render_mode='human')
+    env.reset()
+    savepdf('pacman_datadiscs', env=env)
+    env.close()
+
+    env = PacmanEnvironment(layout_str=SS1tiny, render_mode='human')
+    env.reset()
+    savepdf('pacman_SS1tiny', env=env)
+    env.close()
+
+    env = PacmanEnvironment(layout_str=SS2tiny, render_mode='human')
+    env.reset()
+    savepdf('pacman_SS2tiny', env=env)
+    env.close()
diff --git a/irlc/project1/pacman_demo2.py b/irlc/project1/pacman_demo2.py
new file mode 100644
index 0000000000000000000000000000000000000000..a3bf61d9756b70f810ff3f962ee59cb1f478bc11
--- /dev/null
+++ b/irlc/project1/pacman_demo2.py
@@ -0,0 +1,11 @@
+# This file may not be shared/redistributed without permission. Please read copyright notice in the git repo. If this file contains other copyright notices disregard this text.
+from irlc.pacman.pacman_environment import PacmanEnvironment
+from irlc.project1.pacman import east, datadiscs, SS1tiny, SS2tiny
+from irlc import interactive, savepdf, Agent, train
+
+if __name__ == "__main__":
+    env = PacmanEnvironment(layout_str=datadiscs, render_mode='human')
+    env, agent = interactive(env, Agent(env))
+    stats, trajectory = train(env, agent, num_episodes=1)
+    print("First state was\n", trajectory[0].state[0])
+    env.close()
diff --git a/irlc/project1/project1_grade.py b/irlc/project1/project1_grade.py
new file mode 100644
index 0000000000000000000000000000000000000000..0051778ca320d2cb0cd049b7b27d17004f964cf7
--- /dev/null
+++ b/irlc/project1/project1_grade.py
@@ -0,0 +1,4 @@
+# irlc/project1/project1_tests.py
+''' WARNING: Modifying, decompiling or otherwise tampering with this script, it's data or the resulting .token file will be investigated as a cheating attempt. '''
+import bz2, base64
+exec(bz2.decompress(base64.b64decode('QlpoOTFBWSZTWQMZje4GgRn/gH//xVZ7/////////v////5g/r58e8HvfH2Zx9fQHtgAALsHF1IKAANaFAoBIASUaPbAA4hQAkAADW2Ab0zMC3Xjnvdmh4iUUVQBQFAABkABoDQyBendVKUKFfezcqutgHnqo+D08cekfdvWjfTkAAAHOyQAAe1UBQANfdrB7ZHRhTrvoAABp8fQBxuoULdwO2bjQsmFvtlc3Q6PPkUooW6Se4FHR6DH31925W1gstZ1wbsAFA6G7HwAuKpY+JQcdgAAb3kCqku8egXFPW2tpZuqXve59BQ0KNAMn0oL4Gn02YAAAAAAADADq+qrH33wAAA4PBGse+44aWs6HCu0rhFvn33z4inyqujUXrFOmiA+tJ9kqiRC6H3a99gAAwZttttqSWuvveuVUpOmRTW+mtPnADQUPuauhTooPTHFnr77G+z7sDt7d96hHfVb2PWedyXOmm8IqSaZAoFdxXMNw6px0j6cnvYPk97WXuG4N0KD22PpuVe+4OO6N2ekXdmey1cT0Je3fPbZT6F8fXD7LU9zup8bZtQubT3Adw+H133e6evV97t0se+t72BYbsSwO7D7fZ02dO7lz5DeZemXubTvbZb29OE+lb53eC9HJ31IPe99ffZ5fe2nu7qo+7rHHy+2raAG+46Ny612+eMPdnofe9029957vBeAoNGhutLucF4dd7ve80Xbnte22vt959wfbNt11p32NPD7HpnzBgJTRAICAgBAJoAmTQAhk1PKYI9SM0xTAJ6TTajynqCUxEQRJlNNGlT81TaR6DTSntU8qfqn6JoIYh+qNANNqGQPUBppoDCTKUiSQeqZqniek8kRpo0yaDQNBk0AAAAGgDQAAJPVKSTSaFPIGqeKb1IDNQAYJoNAAA0ADIBkGgGgiREIBAE0AJoAI0NMppiZT0yCmMjJoyE8k0BptQAVEkEAiCmaENKe1U/EGU9Ufpqn6h6oGaRvVAMg0AeoA0AB4oh/tPjpRPmh8ygCgn/EVQICoqkFUCIofjFGwEF/EAWCpSI/WTeCSSwYlQ3TIh+6gNkJvKJMJCGyGiZFSH66MAsQJUgiyCSFOv8+c3/1xJqy2rcv7VKKnlH6d/+v33F5IJ4y/H7fdhwp/zbOWU1/mbM/+POjj/G9Gz/T/5M/7hWMTF5Z/pXlb73NiFz/ohaSteiGJF9yoqSEhCSHHF7f1znzn/orF/eY14434mUedK3ECQjSJHUWR+9G7avSgvc733zY471kiqb+z/NwZnnmULttHLbRnzzd9+rKtRWjS2uI/CLVMgmZ9PJrZNi08Ybu/xmnaedptP9Uv/WjD9Xb/xFeHWHfk/96dbp5viI3CYPXjodigCBwQAQDs7GE9Er/VgVXbVerVX3/5PABbW/vLWtdltRotGxUmxttBaNbRaMW1/R2ukRspUTxbzU0ttYWoSNf5rGSB/ZYCMipIi2II650pYdRZcVGFdXorjJ0ldIZCd3xd2mc7Xdld58L9E7ZyQ79aOi6UVSEaCSRIpJJ91Xmp5CCDEX9hbtNIahKomjTM0gYsed0WyWR/9/+e4//OmioEcMg/17iW63Po5f4S42LJsnL8X7INu3+j6/iSPn+Sh/V5X/2Kerlpp3np2+ubVbigRNh1xUKXZzCfNyUncWnaRCXeXHHp3Slc/5erWstEqj2IdmgrDpSI9IXzIDk8Xy09Vdr47x724SkOvUDjO3zSiEwyTV3si/OsaqBSHzI7H4dXrjjiX+tE4TE2YisLuV9Cl2KCERcIQO55KGJ1ghpy3d8p45B/9Gx7y1khO1Wb1GvL+pc8mFtDP3cI8NP8+h9v9VPCXLDnd20sqCLUzX2NSCBJyG4uj4+3/K97tvVjQOVG4/wlxSP8JsEvyWOUsv7LP5Yr1IM+7u2pOEx6Ib5/xO0Fevze6Pw/5O3tEaA3xEMY9a9DfKD8VvZB+WE7IR1THtucZ49tPpx9vhtnSujNMRmsxTBNcQ6b8nb9Mh9aPa8fJpBAJnzy2e2PvEqs7H43M1j1EB7e0TVY0CQaU+ImqNOXe9MNHREIEOQo8+L4fWf377d0wEixcysFVfxfNHT59UJ8RtAmzqc8cbNTn+5d4Q5GNKwg3aLuuLslSQQFpQJJlCcXzEYl+D1nf39lPI6a9Dum0eh/f7uXt1rDH/GptEmq2HqbL3RT6IZ6JD+jAmW/21v89D4Rf/H4ff13Tk0xqmn8hKQ5xq2hOYj7EZdw81z4w0SUyPr75Yyembv2f8cGedEPn0eJC6qN6Tli0G6OqqBXd2OaZi9/OMu57Q9/++DnxYHQaFWxVZmCzmM8Vae30cSvNUNxH6Nn/Aa6F51o/bT7J4PVft048Sl+we/DPrsd656liFVEo48X/V2ka32peiJsRzwiBS7e3R68saxOLynTzvvTs2ra2Hw139Tlcx9OnGXZeUm107VFeRTjty7LV17FxJLj1o2+btQWEStHLveG2o/dTKnKhivH5ZOiefrxcVtqvXb1XUscqVIuz/VrE6zpn2wTXMQesk+2xlWSZzDp6eF0U57dZ1J2a/CRO+5OvBWVTHicdPCrWqXCM4CGN8nRnpBBwR25ShYSMPpeIshcXiZUvUnORNZy/jeCdGH8qtXbt7JV+ym0hLGOl4lvRqJQnd7qsU+R3XfBilk1X5m9NUGarsiVeyJmExzWyBS+Iqy7AXzNxl859BL8/0nb8SQcyvhFO0kCItHGOeZSAyapn9sokPSt2eIILkV2cLGAuPE63toTpkOk4SYDgzNEXswYo4KMUopaL/x9WCR650GzRKPt2yLZL+0oQRVo3/6SxTDsOCDZyDfsDF+NtWxezQs55IEplfaGC6dpqL/j3aZbJgyKCpCAQm+arRx1ekCEkextEUBxDbEtBDaQsoku3jl2X2fR9CJ7vg6BQM06u48TQcENTRgPC1rbGQV5veBJtbGCAq2pWmvzu/CHjjhxr5GsiCBCEQxq/Rv+zmwkc8h9bWlzEY6EOXk47ic+9QQ4JJJISEhJkkXTgkqowu4fE6cuYlJhrzW64DoszPPIpfIdC6Pa+qiaoh0mFI02GISwWQs/fg4hDIZiJ1xf1S+oqE+cj6p5mJI5mtAnjAxiiilo80SohiJ4Q8Ir1/fz/j7ajNONh0gYhG/5e83ukU7+7S66TqSiCcunKzWIatUWkOFqOFIdv5aSIaaLgmc9wJyxAHd9uGl2GeIvyO5+HT4fqd7Se2FiOlgSdcHWqPqe7rerqUkoew8ycM9q+m1oYRXF92ClLbqqa1mnclI6How4uFsZdEN6PKEWeJmttejNZY1/61dqr/Rs9WXOe9m/w8hveBER+/+HksMHvuBs/YS7cEzhl7pkhZKgr/4hBHKhSjEzYglLtTokGxAub1VVy0cIZBisMR/kHch8x5DXO0TBU6jkECO8gOVzajnx4O1OM8gd7WAEoGB5mzN3TrRo/LWtXMqWPHkZLcL60ZtDXjLhSd1o7qtDTKG1EWOZfjrmk+wstkW8pSk/T25Y4RLSUmbO+WHoL2NGOo+oe53EP2ajx5kBY9lsjou5mbqgmcZHFMSKPIUIyMNpfKuCfHhiNcnZq5zCT3gaPHBapocgtHCWCXDyzkfXTltpSmFg0E1oTGQ5C7jeyO7Zpz3Td9pRzyNtMqIvZ3dnwSINiHpa92kFegjbYXviciRYvIvR1w01k6MzRD3udzQ5OCZJpHV7GK3B3lpJ5i5l1SYV7y1CUp7H8T7YnAjlXMSFKRbd2ySJEs4gpagchQd1nhuzvlDVveNXO0g0EHENzwWfS1G00g30KUMpv9FHpg/Zb7+z4Z5G5QcxepJp38J117YLSlB06T2plW4c6BpOnC20yjGY6anWc4Judhfi5bWmjcFWEFjv3iJHU+GByPMpicutOCM33TRMHcWXAl2crotOvBzcuSwqrE7Tl1RGlDvXw4wbyP2L0Nf+++vBqQNtv4SN+pGQI8ednfLKNpGNSXNmCDJaaeFVd22JFBELE/Bp/o0/7KCFo/ykN7DX8o8CRLMwzcyTe/puNyouPGYeLNQ4ZMVINkdyOgg5U1uNCPhnRiZgmu2TcI12R7dpCa9xBI7h0uCZ5T22Jcc9LlrkVsEHtmP9scacjiTixbJ6Y0SBF5HBU5X2aQ01NNxv3318y53VL/DlHOxxM2bQWfx6xkw5UuFbaO1SdKFo/lmtVqMzhiv2pAqQXb4CKcnAzQHv3h6iTTEpCVCNiWgtTOraSoQ4tCz5yJpuybMb+2mVie9N3xg2t/KiGtXD/TxO/8i7A8tX5GudCTW/RBqSX4SOHLzjB7DvXfFAzeZSMrKNJQP9m7kXZ96lo0lRHTt9O2Dc7tO4gya7JZ1IJyJfEgg24Dj3HrxhlFta5W5e66gL69zgFk93oNCQr+m53Z61t2mzW+UTkXmmtCBxIS9RS/CzHnpTdt65kJZtKj69vrN31NsGPVEctzIg7aPanEubmu+mRcTCgscHJC1dJACEhBRNOxnyJZSQZkGVygTTnu0y4HFEzUcIQ8pXkxjG+h3sJBba9b/Jk9PLt61tlQgOp0v757nT3ulToqrl8+WZW9QlJVZcj8EmNqOacpdPVy7xzebxDjl6KHf7xPxo/tpVqg7tNyb3cVW8g4yEziNChc114Dv7T35zy1zxOgtF35SmLg7qn0xmu2T9KSzMTJacUEeNJppLvet+BlSV3E7vIKWpsuNJomx730O0kadHWvugvjc5+y5bXua7i6/CWn55lC3Da1NMy+OOmMGZ2S4191aDnEpyrnm1pc+7B+dtjI/i7uWDLMgcOAt5+zoQVrtfj2TNyjZJlx6BpMXt93/pp9v8RnZRnlKI8Pp/BdrcahxIfbA9HcHXgiOU4m/FzxkX9TlplVlW9aSypiRE4BHtLKQUmj0uEFSSomiCRjO2RlSDhdnY90AD4DxNrZ50wnlJ4lJTF7+9+dqGRlf8YSrDJ3Eh/FxRAR0xs78C2Z7ORqvT/bkkmtcfySPzz8vVbWPvl15cQiAul5rllqA0z4pz0JK4YemD2P40kyEvg4SyEdtBylIHC+Pj64JNys9TE5HKJQZwZsOq9yK/N8XthywmLCttyli0qFcqDXzLTJYvJip4fLSuAHLXVpyiED/g+q107vk310uK14um4Jh1E/20dEma9aSrNDl+vrT0V5cIJBuKRp6HLkZYOS6DZIlNBJssSpBKf2eOnDliKHTuzzLUdvlcxB73INvsjpfXTtflHoYOTc2Uji+Dt4585xW3GVOyA8lwk4JJLRo/PdCMEmmGnyJzgaUeKHQ78yNi0XVkPLlg4caekqdHz+Pn2ddMO5XeWXAHM5GZzI4k280FI2ngu7efc4BbC/AVf82W2VgtzI07BGKNSsjEpX7Yqqt4Xp+Tv4mL1xUs6Rlz5O4W111bRrZmROyv3z4Ao+j0cou16DiusNDrLEf7JehGtGF0Nmq+/WGC9+XrDC4OhEuCFXrGUIxZUyCApkU0Ru9zvLOdibkvRXh2WKDZk8w7Obo5X0A49z1px4X8llx9H4R2GpYrqbb7DeWw/cgs/K47tT6VzxexbHwPXEv71uBpm0ckMm1q7eNhfvQc8VILmkUpUdZuPSQpnyN9F5VQ+VdtSbKePVkSRNF6CIkwxDVJ1buKncFg2zFp5/S0m8DjwfH0mpVJp+D5l57HdTuOEPCBeQ5zQk01JUfm6mimBCViMQhY7OZbvxzcebgZ9Brpq68tKOziZY6EiqJGrFQ1xQQZhKXDOZAnYJNlglmZEl3t2VnI3WBQ/W/CstREgh6ZlqGfDKR21HtQnG2zUzkHMKTJyP+6dNK0XKGpgOUwpXI5hDQ/RoPt63QRIkyM50sSGSGIWEQkZCRKKoIEs116+zf6cr2zt0mXmThud7wEj8uV69Z9kp2zu+s+S+gKoal7SDIJjPlbYWw56usqM3R8zYdtubD4acjEplw3QXjc5GZYIQq4PqvbNslBArdksjYzpbK+o3xILsIjStZcyQ5xzbRFyQcSuLDtgxU02lR7w1Id451oOoh/BAP7aW2fB3IeR9HW1x0CSoDjOUgbNBWPBx20NbkBPooKEl3o5EhqmCuUuSnfTHSG0takMVLHkkmadTWY+tjpUfQabZBBJbmfAjhkz6E5VJpzz4XOy5Q/FIHQtS0CXCODrLdWtrlYHErODp+WVM+CM0stDR6O/OUs11Lczg4JJ2czzMyJ7kwjknvKK69DM0CfB23IVyo6edVLiOpE3yzszm2xTRs6HEzxnI8eQ7cK6hgkyM8ZEtlIkwckfhNfnOdeLLJzxMrmTCd+RpCTidNC+tFxHuFCo9SOOS0XX43dRgvodeFXzCC1SN+lYmWWKI5v5Mgp/LIkpjNJU5IJg2KyiRdVZU9nbsgWKrHhBNIh7e2VUk6aO+0dVdQxEcZvTamUFiDRpZcuDs9St4Yzg8qaTJa7Bku9aiNBSQJXEaVxnhOWr3NMx4LEd5nWXPOHT0MvCs3d+yj/WczXMcw0PoK/Y54HN6skkwVyysX3esOPiZzmURwd2Mk5lwOrkrX7bC7tQ3XZu5XzGzPJbGDNnv3u8sWfhv6Ouvm02kzjnPLr3Wd9Ro5xQ7cyh2PU46aypGN+mvKFwyMkyMTcq23Msw6kyBndmXXRSXZWQ7qUToblPFoD56Pw22lhd3OTBugtw59syZJNkDu1EFy4hE+nWeZZFU1XkK5J1MYjcTsMcYjCroCEF87nByhJ+mpJrMeonoHz/JzsHKwOGXM5BmaAvJOZlriLc37FmmlTa2j1pzybUtF4kRStpeOVcaGDLKRhYnEs5vk0Rc4zveukPu5fEliNYxPEDjVfWUnFXKbcKkvBpwZ5ltrtpoO2cZXqgS0CabIxShYvLFR8hTbCoXqbCFeYmysTjENfjmPn1acHArpZzbOlXftrIyUszMHhE3z2IJPt89a6XB2sO/Ca5429YxHwevHtWy+AWC9wmY6GGlPIzmrsN1ql7fHQQ2eSau56TjZaCoHUNxHGkZtOtQnVrnRbMsrV0IKnKTSpKbVm4TmcZqVevGhdrY2tM4Yc1tMfEpS00qptJSnVFHn6UaiIFlM3Y6Gpg5RyD+TyJEOiviiQO9ch0gyMSzJHFF2KMTd1UsTjQ/NBWCrnU5R9jaxFzplvoVp1zfOfCQ7S1yY35vHYbYrU7OrYineQEq9Zmlc655S8U12mTc4FTkpTbAhdXOOT3LlY0EWZcVQccqLlIcoImeHMrIrW5oqIirIxR7lSmDptKUzjc0RosOxX6WacptV22OVS58B91nh2C0NEZupXJDeRcmeRQ+uA173kg0PCISXPPPvRe2poSPyrquRmOGYX5SIuEoI5u3Z8ydbuxd1X1ydvBHkc+aMyiy4/X10Rp3ZyXARsjgZSq2MyU338uVyVHSooo7h6t4jJV5U8DrK6TU/FDZcMp5T7d4JwehwK5CLkUp2nLqxi1ss6aN3N2YLXzIqHnMvtTXPS+uGx5M4z9fjpoMLjI4SNbFE2wjU04j0JHBysG5ebj0IDBR13d5fIJCEMhFQ4kmrLC4SFyzyFBVBoyPlH7RfScCZ8yMj1lyDH7bH2GzFqMB4fbmd3dX9St3O/mAP+f8Tm9vZXs8PdXrt1iKJj9X2Ht3HGHbIIIUQ7esEfoX3MIPuqOf5uO1MBcTMBcy+uDwhkfRt03bdhh34O+HqOGYIkav4/7B/rhPCIFSJIKkf1rJFCxxKucaWJMkhMJhkrpx3EkkkikuOriVRcd0uSMVJJ1GpTRD87dWDKoEqIEIiSI453R0dTLY401o3Z4HyyLy9jwcnmq/rU4Hlo+kdIeIn2SJR5Wtg+Yo60/B6tJTsRzPzmP9ctc7fLSkWpq3r/Q+ccI+2xpYU+fOXB5dE3X1dkaiPXs5LD53VYHMp/s54mTp3bvd3f57YiRmLPHfh+4346yvfL8GcDypKZOt4jjHWNNe+vKZrk5xxpfTl9G+tNOzR4lmWLuJUh5qQtFtOeJFfsPuBA58qb5pj6JvcicB1DBkwbUPT0l7zufj5Dt42j7u+lH2+xvcVnqsRtwDl2FCBdv8s/jwx+n09fzXMbe3p0lx2h+OsKC9N17V+bv6T0tfxx7O7fhyWvVdpZ2CbvxzjVZehqISQtXSHDueI+/ghBTCCEIsEkB13cnavXtqtfqSHQSAjjIQlRB9A3BGF2tH9ria7sYKDMIwVuik2FW2H/R/ldGkUXrZAcYFj2QGqCR1BKhJIY6nvVHfswdN617UAQuP9fWAsmOvOp3PJvlv64bS79avQTF09I96lOp+XOcX/k5+HPqvwPmFk1lr0fy/mkflkenM39XPhu3Bak+w6cn0/THOTrcLwQkX5B9eQKnmp3p46FvCNyInlI+GBIEcxU0/GAWIv/v99CR/O/u/TYIEipbkVUOA3jVViiSxFpf53RaSvTK0sbceJ5/a1maUx0jHRiBJa1KrV5GIxH9HDise1CUn/4MYIXHJMpNO1urYK8WfoMKh/b3lQLNTlyNtsHs1lsRemJ6f6dZfOWixUJrWf1uKJzuXcTgy2nWbklyO3iSJmZrLRoWhFZhX2/afkvhv2nd3wcusi3MT3xoUPeI4BmUCE4IP71IYQu0D1Dn3Hp/Q1CCZSZj+0qmEX3fD8Xt/wBPZOJZ9dfFXz4yo9kArJtAzVEAzx+rH0fodSKMzNpcWKz+UyOf3/DCSSFAEJW+42t8m+f5vmXPo+HsJfemumIotoAqr29+1T4db3W+758fh6V5+V7PPK9RXu/IItBb+Fm25yr5CEnIE1EjWkazkJRAXaVA+2zzpBzsfJwuOcjjn+dQvHdKKSDM6P3qp0OrjKOXQ68ipUYGF2EIV9P8o6aSGVc4oTTqoCwgXFzAZEYDYtJqjW6Pqdk9GXr/P29/rnXsgaF06rWx9CCsQM9O6lEMbTb9v6F9PoZrUf+SHd0pcr2/wZZaonURHhxcuNMcbVKiJCqahAgRsu7mx452zQZJCLIzhN6mjsreVCBpVyRJDQKH9+xpB/b7d2NNPWyVzDTeXc+tzXbyeIb+TteNcQ2J/Pxu3pM5zQ5rLc+W8lPjjd/3+mS3XMY+FTm28f26ubU3fzb8avb0hKds/jB9voSSMtjXXpWUf0hpp+2BUXsR9sNIy0t/DUTSsfN/oRRkH9PXsjrEQux2a6qU6awspUWX9uX02tbY7MhxN3TGJiCiGEIHOX5T2pq0TdKHfL3KLlHvLoSnoKWdamD2TkmkrBSrvPTDVISFpOeSc+MO+sMEfZOdVf2vrYPLNHy3rPCoEKsvif7QiizHXKM1CDhX+L+W/U4eNcM8nFrlWGhe88MnzmhAzlTMDqNustpjNVNZqSm04uPthLeuXvOZeCiJmYUaB0ZGYRQxxkTKWaBwgEL/cNi82HmzHxTbTrExJbr8paq6NKIrxnNdhgj5gZrN5dIjis9KbtssH72nQ4j8UlarYGv8S34IqTu9Cv2ql512iBRwck5OA12sxzH+Q4F7Zbtg1JeVxO5TwEW2DQEfVzhl2Fyd3A4rRXwFCLoHExDTFQTk/56BLEwZ68JexlHKwdMZbHl9Y9/Fk/qyb0J3MmPU3FpZCRURxPIt0bPKzv8r/BEC2VoHVOWaIUk46aXgoacjWB9Ze//Z/bttsfH5a1rcyZZew5L3oiB903rNuzScxHutlElHHMiRJOZRQpKKSaY3ORiKWDKV61+jxutf2PtVfnbpVxedYOerrvwaHMMZScpIJd0gf60fVsJykKvslBd0W5eY8Z8sQVaXHuwy6SRdX2hGieujWexB8GsFuxh7NkpxHsIn6he9X1EY6Vn2qZCbLIhH3kQSZNJLeQpzyqR6rQW/H8/r/fah032kZ8uFR1IqoVo9c5bSnEoWICUqqCU+x44o7quT4VhfTeCF5L59L/VI4WPkn8ZkuHsfpKWxLWSflHdiamnJd8Eiz4VCgpj/KvXfKd5/gjJ3xKJJmX7CU0g7Pt0jqt+vI/dTX11h32WfGcUl+ZpeXZK/lYMKo8vSNsO8zK6TSQdxN+1UHnhjOjRKSh/Fz6k26O2Hx73258Kdxy32fveHSLodAJBVXhP+Y83N1w/oI8I69hjP7INfhdy3wXmvDE+I/r9f49g8mIO/TqW6MvPM8z8/r27G4lvFHlKJ3JmRUfykub9Z5GrkvUnF9IvIrXheRarOJERUNcKtrw6kp48jEmpNZz85zkh0lm/4EWRdWo7L73HQux2M9JV8uHCUklprpgkKeH4Htg4gqF1alSakImfMJkL1ehLql7/psSAySmODhh5v9fSe6pVnNX/pk0koNtlKRz+Qg7sE9LdPbbz8a+y75MeAjwMecM2vg5B2uJSMO1kxFHGxv5YJc9JigpZzRSkKiPVj6ILI8E/V+eT3yz+n0pT0vjYk3BNUXuKj8LVg4SLkcFL9fwpQlvFDhOalJ78vo8Zk1xAoh0zov3Ks+tHpUR82bkzytQaCRlRn7BQElUGtsy7+PWUfWqxonAMsOx75SJy4Gcp6pYllnd3zrORaFbb24xixSSs81Gd6V/DN7YIaeFfC0oP4WgXFN2rv2f9Vtdy+ek9pJodMj/etoFh9pVS9H2nn/D2RPR/BcuT+zLXxjXekLl1ru71o/98bHnemciEs3tCVUkq8o0572l174OC03y0koVskcnfW7zrK05y35vQlPNa7HwYcKU08oK6GId4ei09rnvm+4hzs8sPfEDqH4dF6W5+p7FUq/bLOWdHo7y6w2h821NsUqjts5bvxHyYcFzpB8M9O2R2+F9E3vXThGxJIsscbN14z+qW16Tl3J03rvPhM86dtdSeyeeXp9+hFJr519li+svG3Pbp65ZbP6Z88jx9JRSOySoaU9XseU35tV+MPh+Uym8+Em5Ivd+NH5KWQuEOumtf4LzU6cF5LZTxr8l+dKevKy5EzyPZXrQ2s8lyMnudqnhS6Y4SJD+GOk+/E5aW+znzrLtVZYn5cY+6Xlx1ngdAvq74JJFeKgkniIH0+MNC8V1R6KXXEcdHYSJSVndECfu++Jau7l9E+cp8kPREvKk38IiT8FCQvLmCywqAm290/XoX4PQh0srQcYlplnKUn8rSZe+7E9nJTlOTqUq85zFJvODEUT/CVD1PtFO6X5pWzdNLo/stOaUof6127qXOUeyW8UTMon57Wz87FDRFkbOSk7pAkEq+v1QaH3ex8fHPoOrqs5U/uD8AZramDPifuMA/h+Gup7S6HvuUd+q74yE0V6/fgBNxBkQ1IpIwQx7PVrzl1+6sTS6EhwindPw4fmy/AgLAHfMR/DQDMRITpmMn6DEMHjxiUqJmpb7Ityo85PXNR7MnqKkxyBawFkWo4zPnUkkmPoy6tZZCbjLvGdX+6PnXt76Rt3radIl9Hx+6Skl/dvc625/L9nq+88dOy/ao7CDHFeOQ33f4UJXs938T09rXRZPpnbt+d2bqpvbrz9/JZ5z9avjEGSpV5tomWbx9Kb0nTpZgnLpcp2E+ns7ApbgP02B+FziUgp5Xt+Lo6yvgy5uPaXBpCt9ZvxK3N8o71K7YmpnjHLWhRSgNFKGWZA3KonwK3mWv5/hsda8lfxcdJlqnTriiDIeNaumKqTHkTxeS8yXp0ik/PmWiYOOxxPD29dSiN0cFAmvFz1ctKmeH4Luv+nEz0p3wZa0ntriCn3qj7hc5yTzXIlvx40jnOqOhGcGzk42sbTkxu5KlygULaw9VIiDoWDKlNKP2a5yJeVw1buma04Va34Z54GZWCzd14EZk434PNbObffTM9Ye6zRlxntVhYsQt8bIXXfp8bDEyGsJilmdtS2UKicc4+FpGprHnp66GueRF6P2cufZdBczqyJbzIJex2M4X38rFx1o3d26ur47eBy9CYeLanGxvq49+RxlMzx2+3dV5z6+N8GnXXwP1nmgrvl742hzk+fgcdX2kTZu9G5TnE9pwdOzrv5MHnbhxusstCVi3FpFHa9CsPmdFDEIHHfXyfsuwa6VafbpAR07LXJifyKtLs7bjm/pxlQyRhFLuGSGhEm8K73JxanTh6UbM48ecju+j6WEyBkIP+DmofW8mIHn3UcjAQ/wIUQHL+9k/fhkfHcPwizBKg8hl2lGMsfuc+yrdyfuJAerxOrLiSPH5bkHffl9JU3Al5WiwWRnA3A3917B+TuuEZk+BInb7/o0vwFfaUewooJPyzcVJF8TlNXFAh/mE+7/Ru9jMp7X6R25cFVbamRqXity2M4w4tBHyfGUFC9YznppJ/qrNqG9ESWnF4/jc3eo9POsc5/CtRV9Nb2fp6fxo1HQ0upOFS/XrS+pnnXTzrB8ob7K3ap95w+/w2/b5DlzcXfhxky2TGeTgXQzPZQhaPCHr3an5Dh6DbqUZNHY31pdwkJj8n4g3O/LUOQjivkGTEj7HB4c6oagyoDWf/YjuOCL0pDnnI7VFenSnbImqQ/lKur08vGuPVPLLOdCUpotIjJWriZZOXE9JFdqE6T2ti08KeXruZprWd3J3s9Hz+EsaJ8VzaJa/GKU1yz8fDbh7sVvo+RbZ6dpNJAkvwJ2EhJJJhpkHB5QvnK+7XmhYrZ9elCP9v2KqsFlmW73wmTLfvPo+5vIPR6UmRky38TnkbHko+cbYW2CIgGpZuVVYIjeHDKdLSaQZAlYitNgBiOktEUFSCxEPh76mzYUX1js+ARKOFY+TaliCd6YX8DgB6gN2NDlFgQmG7+xxprUeq1sQE7MbTmTmGKF7EgzNwbv8PN8nUa8FWP7BgO9XxXo0es4mpyDXQYE3JDJgIF4oZw3FyZJdSrFz8iJGtc/BYFCHdF88t1Nj9dIbOGDCHm9RDvLNSE2OSjaxPubaCBu6bnMYUw0ZpG1f4eJ3pguwhAj3veJNu1YfA2MbptkVb2DccibO30OyV92SqROVhxoqPXKYOkZ7YvQs8aSkMh6TsCngOrTs6QISD34MB6qUGTbgeRPh5bV7m4hswDGGBNxNqJAhSOnPQZuJohAgsmSZuzel2WWTWgMHhxKOMmIFRr1OjYasXq/4nmdseZKE5jmLBzDlpbMaJpovVyrMa7RNJe+3D6J4VGQgTJgWAdlerkz07SJiN3Jx490YRJEI9XXOOaNELK0wWSYYa1JDfEMs/DFsCXdlSsjQ8o1haFDKWNECQhVKZSMw69xDXOvaxiTI2MzIk3lwUKOUE1N+SXiehHJDn5/PjTRJW7xMGCLA7OCc4LOh00atQQgUhG4mKpIuKBG/F6iNQTfUbnVvIY71Q6HjqH4chMx1/GtQ2gy7TkFxB9sqhAUjm2TaEgsXJh2yG3nyqF6141r5NmWJ/DfHPgxnmZBX+4vQ5BqFA/iDzNtDbgNmwoqqH8T5T/QWiAgecJ+z5vafSzY/3Q/F8eP2SvyPj+ZKQGNWKTlT+R9aET2KDZ15Xsppk9cVShln7++/4cyEgSO9lqEgSKe4VD1/K+9w1VRS1VRVS1X2fT9X4r9D872/i9/X8fozoaEPlKeChW+mJZWfShOZokntQljK1ZLjTTGJaaSvalcpa3lcrTTPONY1VLORKmbDExmGQMQMzJCWXWgySGkZJMIZBUTJEASBirAgrUcMwgwBYi4WgRoCkSlQjKRgKU3apYAxBjElJZIaJkhkhTBiDTIPGwZzgDFAtwy4AMoFqJBGkaQXCYkZIiiyRkTzJgTA1DENCwEgFo0qFK2NKpQBY0ikG41toxAW2INBbYIM7GEW1oFKALSkEpG0oQpLWkEqCwLFhFRpMgYiwljDSdgxwZ2Bx2BLck+h2k6KiqwS6sxGmWtIEhDJOUhyTRRUleh1nhJR0JkHAopOHJOq1EC5bZkicllAULXD3EjCkzARWEzvZ3bjUWonCijUgrQeh44W0ki1FkaIqBEoJAvQESI44XiOeoywoCuqziLEMmihc0DpsaBKtRzBk8zruXRfE5y456Xdq5ktCiegEhohJdkIxYdd8Hjtmdda68+deLEiz3yz0rnaVYxnXEY1nnmpEWKYrYtDZKxK9Iok++TrucvT13ycTWuHxFfc78KY965vriNeFNb3y+qrNXeLVzlkjR8UnrOstTKlE5bDovpDoz0xkS1m+7kWjIWB0BzyjweOGjzWd29RNLrxdrJ6PGsRN4pSKXfRUjXOcYzYpdPa8ZGr41ywUTyxKyGdkISdK1BXk9ddJ0o+sq4pi8oxZ8spamEqaaQal6PK2r1zjVa3kpXWsXnrShOuEJIeHIZDzzryY+Pwi+gztavo2m0ozJkJkVtgIabMATTTJqqjJZaM2pUrNqEUpm0tZqgjTbLRI21bKFKpVlKpazCSZBS2halkKlKG0iS9oSaa0yypNFhE5R0zruXTb5TvOo3XXZSXdRuXZdNKVEUarIhMijGSAXOGzMKRYgKUUs7TDlaznTIv2jo5LI1oqoPB11Jl0iOQIgk0hhIKARD1ym+RJaFn0xiano+mmMRTBFb2gyZ2imesTxladK511rQplmhKWVXzopSpa08PmYvbWFe855GtNNc7E6lFLSr3rS9q62U3ylXMVLazNDXNEq+DlHlOtuDuXZznoku6EkVwBAQp1utdc87a30ilr3vW5FHrV1adlm5KVNYlKVcWgVKoyjXQ1yrOWQnsz3eMqPbK0skYcWsJ/44i8rPbNOe4zp+Dx6Uma1PQL7F2BLjbSYnz6cb1G3G5MV3bcbm+bvT43uYk7V3aUikSbUjUicJJG43FhDYVVGqQVUJSRvzJXU8qxNIBuIDcF4RczEqSG+JtJNJJtVJsobk9Ie3TpCcbfJFOfSY+SEjQNBa9yAJgzSPC5y1KrlVwgSqtiC0WjbxbxteK3zKvTW9TelelygtUkBYqIgSKEiO7nMbdiWFYiktsfCHt8STx5wvp5OeceILvHx3JERCRaqmqs0pcQ6gh+MLQJVWhFYgSoEiOPU1GxJYYu+XVWgMRtBqblcx7W1UbF5dFoIqxANGtOt2ymqqog8Gvi5eKjfJyvgua5e493wQVNXK3zhocjg8V55w8Wy220tsy6qPEAGYPHAqy5ed1eaIoAojAUWKL6fh8e8r0KqKenbevIPEULvV5vBVwuPTycHRPVhVFJ2lVF3zu+59GMb7uDeSUwiEMZpIskw1GgjGNsibJpKIpESLFjQBYtJpIxSTNgYaMUlBCWhKNCYRkbBWEtERQFIUYksWYFGI2TGKMERRBhImaCoyYESKSgNSGJmNFMjQYBMJoTREQWE0EYQ2goNkDFJpMmDBhMERoTJtoxpJEgrNmMFskZMZGASJCa20WKIiiSiCApCMVFFJSRskWFICNjJoQ0mTBjIlBgwhJYi1JiNoi2IwGIKmEhBBCCUUQYpkWTCBJkKJEgqNJsmMWWaSyQZoSJUhgxEGTFEzRiGVCQmKtXa9gbGkaVTFMy1675/bx7eXyXfTiVDb2GHYLKs0XrTxGsq60GWWMCmBr09A0m02nfia7sI/OzdnZ583DGlWI4LmtnTzz6545IEzogbS2RRZKKVY1NTaalabZs2bVZVWaqi0qaW2ZWWptptmba0iukgQUrXE95OfO3aLPDtpCEJHQgSyR6/s9vfr179YPXgmMbNmNjy8Prra+qAiWZSRSCSURijAURDIkwkBEYg0MpKJJMREkY00MZmkkgJIiZg0YyCQkmEkkxJSSVFRSY0CYkNiCTQkYyZIUgwgYxiU1BRo1o1CAgsQNbBkJpQUlBsiswxQWQyJSKZjBgiQZJaTQow2CJlJMqYFCmGAJrRhASxJNhokiZAaJiaIsRhkEQswplCDWwZCalGIqKZWEiSkKQZgZkzaAISxosSEt+q4URDccg1MzO3NBB4VLxqhkdK44wEiQ9pCoiQ2Pf13115J5727uzh4aWcjBqGr008Pl3qALcjBQYDBUHoiiD3ChQlDoSSFkR0fHPzbHYqoNhuiHh3deXmZJCEkClVb4UJmbbG0kgPiYF4MkIuw8yGpChY62JNG+E5+e0yzKx7K6CuHxGxodh3dU6i7pswG9C5EhGZ8+20QfPfpqfMVdB6CyPQdu8tingVuLi+VHyHccvXjtvQ662viIkXi6trUggmbyZrCD5BZDKHakexER1WJEDWJYspMkNGvDdJR1RDoiPMrdAmGruVV1TQW2JTIcxuGIk9etg1rWiHy2yQT2j0yVkRJVU5SJx49HMCJGg8ok7Qk5fCqlLLL2kE3iRuSlwRJgWQceeCGaEi0kHeGtaG+mRCXaIBKyRJHUkCQWRIbJ3TEkMgUi1JIebCGBQU62DOiRZEkXpckDQUlJIzJI7qRKkqINKDiyBHfUyQk6t52mgaSCQ6RJKQiGSG8G2G0gVISdpQjahLJFDc6kUgToxzCwc4mewyaRJNpvRrTb4bpuio7LSyxXKQ9wkO7a2xtg1jRtQZMRU+H02PYRHrhEna+Q7+vWL6iLb4SR35I8u9GXVt0Mf0K1hwNPPX9bYTTTH7UyTAOUOIl28tq6rusiKh24xVV2HJUTCiC9mncAbwOwbBoHzChgUKDSD+VkO6geHLDYOeLbaYKm2KOPDlv03KO+o60pn1UpyL4e7TEmEMzBWbznosac56LOzi0GHHABm27NM3uBM1ZIcYBa31vG2WarppNgyAkjKmdcrU0ltsiTYKswx6Avh4noPp/L7PDEnXztHn3tUy53fL4/JLZYv7tT7I032+eGJfFr2r69N9q8bn4bZSJE/h/Jy5jNfZaTsAsRD3lD+AzN3+aHD0ZHlJkHrm0I176/mRKvZstaB09ysDe63WguMFQKhUEPfjX1a+2aab2eyqsBUPcqqPb6GGwHtkzERnw3NDbb28MU0fbNmGF7epXW2vHfEtMmMkbLZsa70mzM2pES1nbLI4yMwAMwQA80W0edtLgVz60URS1Od8le025CsVHcAGeO/OcyZj0syIcjSpkAqZa53xnBWtuPNRAU3qCxCKiaAmN+lnTZWjpz69Dq34U5cz130iI1QO14avTUhtdQ9wEhSK0MUWAoCEVDp9uFVV6AAHMkyAHK6BFN+aBVOO/PLlty1JdCo3FTdySgKYIK9cRdol4RBpE1UEzMGvwWfHa+eer8I2pnW+DViS1ZgGYHbVnDIxLa0Zkt4uEXySqAAAzA7iJNKuueF6l6Dv2ey/5SS0lX4TZ+89DEJMhKSbtEQJkzIEiTMGe/LRu3rEC59i7JNz6DCtTtlMtjDrvJOhjLzG8PPPPRl2RRFJnLehWOcOpV9oPh5HvDgqxH+fr8fPoLLb2ROZbhN4Ryn938fD4SiWD5UW0c1s8vjqUgeW0s6+nDfW/rJTjJi/yYkHEG7+6RAx5geUgU/MQQbmH1bq9LZgO5rCzV1o3pLVGgwMGgdoIKm/ritPP16+rGcK0Job1md+wkAMWajA0k79psH3BtIRtboLQmJEmeuNQ52wGk052cAHzw6QCoA/I6UOxgZIR4DpMnNSieweW3gOA9BpuHTobzf4fDmDeTg9BQ7BsGTYNg0FNDWgwcncaDeUNwwDJuGBQ+AeA1NByHUMBuGGB0DY8B1DQYGwTJQ2DcjQSmBQwLO4e3ruG89DuHJ1HoNw0NB5CnTcMDuFCYHAYHUKDoFDoHAs6BkQ0GTQOgWchsHpEOTsG5sdjwHUOwNg6UNwochTt6DQdCOpcD0HEGwdA7h4nAdwwOCHB0DoG4bBsGBkwKDzMOweQwNgdAop2MDwHU3Dax4DsGBQ6BzKDCnwOA6B1DwHkNzk8hTAo6mg0cDsDsDcPYMDQdpChuHUNgwNSRgbhgegdgwNpk6ByHUMDcKDYOgYCh0DqGgC4BoAc9mhmGZgtrkMUfGuUgrWcSrutde0kjn36+0RHbniSR3GltC1CvDpsprryHN4IImRBItWlq21aRMaLFEURsGiowQlpKiIppRZNEWMGikxYNi0WNFTKGR03EvcKqjuNxkdYDFeohCQJCBCQgiIVpIgQSBEoywYgkAJMJjQbEFBamsjFgyEREwwkEgRiKSKSJCDERjYiDJRFGDESBJJJRsSbEmKMGiIiiApIiJlkiCCBKgyUgIySZKYlGRDCQJAJhCQgTJZZSxlItNsW3g3LZMMZTzmpl/0QUEr8L7cIUcOFKClwZm1ZmedEbD6M/Cc7TZmZgbLc1k1bmi3nGc6UcUAXQklsBmi7aic+YHMbaKZzbFNIIBbEIxZLYm1yt8HM4TYbwthZBNoyFewQzMA6obIUDGtdsoiCmeFc4b517ts9evE5hDpZElILbrttohsEUFiWEiIodgshiQoZYONSQQiWWRUkFIhIuRJkIWeMkEwOipGAsh3sHabTjQSZVM75y467K8K3w5WG8YBB3xEMhOkOJDYMEoWdnpb053cZx7dem7p1nFLLKWoKslbr6TcqIkkiLJIC221QoWESRLfbtHlrz61v34ROgdfQbu7dhGbNJJJP+2pEIeYiEToAqKctVVUU0AUFCUnEMe3j6sCYSK/IQ3e/ZHU8Pf5fAT9rXbu6c+3pw7JxOOd1YEhEkmgPu3m1aXsvrq/B9jvxvNVethUBU58501jbbWE2E2G4fYGpQYHQUGweB6dEk6PAV1gtXcWPwd++uPuDQbB4DoHjgNjecBwGB2DgPfpbO9MhZ5CUeQoYHjTiJnaDZrrM9SyDt0tttxHv362VuG2ZIcyRQd/sfGdf0w/i+x+Odnw+j1Zy216ZWftDeDtzOgTtQRxEUCQ2zK1qKrbKVsm1rayUkkVUQUVKshK/FuaY3XNLjU2Gtmq+GzYSSRVgFFjfJd63Y4MJg9GQzgyQINRGiKooQCebyxVTtXs7LUt3jMZ5dyG7nAmEwNchiDQuyGC8VQBorzDDrvlScbCz1nZghNMFFgCwIAszBUnNYTAAPiuWdKypKztFFlqrPSHubU0ke3biEbhSJJzv08gJMmeeKk1xALpmA0GYQaIV5vnpKla1pXI0BI0AL4gbS2rARU0UavdSzAILloItXIg2iYGywEIrSukmHfRRrpm2rDMDFjbPGZV8Sw1s2fAYclplrVgLU1na21baW1plkAJskAOWYQ2YA8DUgsWKPFZG1JuDQcUNCHGwQKRF6YEHNgFKhz4cbVDMUOE6Tdxvl00zu58VS7560b2IDMuIKZjINqRlQakLSyTkLAoKCwLIlqKyREuQDfWPRSESMbU1KDABnlVRnZ2ahkBIYI0yyyoWaqts5msNYZ2ZtUM4o6aI8fJhLwDfXjvfMA5SYmACANACTJZ8t52Y3QABuT4coyYmcovk9ts6Uu+dzAyDGuqfW+mstq4qUyeml7hkNhXek54t229sdVIWVJ47W22zYUtXvtPAUFRe3w/l89lvfUPjL7jd3AHbRIE4SwHg45qPRYqwDWahVamXZNWWILKuwGBqsz09vj83Xv244+S+Od9dO0gQeFIE5WREMmwBDtXaad9aXvzzxpXDG1bqpXmrqrzvFaHKVR34krnzllXibInQEgQAikCCrCKFCwihFlCkTrO0kt7ZLyoKqiQAgiKjzg6bYATTjwmeeUlSu2eVqylO7+8ZJmMgxhmB93crss7hIMAEgy32lLcvgLVxjOK67Vvrd5ZqeU8wzCldGZhs6ddQk0glshFIJI06YeK8Xl57+O+KKtytFUWdLriTOjl80sypnnmjMqqT9OeHTp66++8kR2dVhHhzkIjVV330Gb5zQwLANrJgUKhuRTBLPAxIusjdx52gRsJKWRCbygoUUKChQULQoQApHAKKJHCkwEVBURtCKqSIqRnCJYShd6IjFoaJO7NQc+MkI7DYGM8b5xzfPfnvQdahklkBxGUjOZInVCQ/4n+0lqim0v+OZSzmRhLq3dCQxC7IlktCoqZUOnEgTiQXTlBrKCWBcLoWEtQ0TKrlFFJXYnaRTFDEYyEJyIqJ11G5jF3TEwEkQpgyLu64iaMyU2DuCTaTMgdFRUaVBRXMZIcKIuVaaJgUQLrdq6guKIEkMVNLytba7t41woutoEUcpawrkRFxohkq1ptwyds25Lldg0YwdWcRMyu3Yo0UURBpW7JnXbOmWHWnWHaULXShKLZwmbCDltiATDGVJVBKZC11DmsRacIuJEol3cpgDjOTsuuuN3btyoNyMYNXMWICwwk4yiZJbl3RhQsq4cKQgg6LWQUdMV22xke0k+Idu0XttgZHaCmwHGeJMpsA0OFNhogPPVBRBQ7N/Zjr06uzN8U3MI7hmBE9b3bzrnxfjycBR06TrxcpbJ3pnTjmDYp9fq8q5+57d3vfbuEO0goEFQI2hutAVeZ/YUKmRR0OvqpR6KqopvVVRTRVVFNCB2IQdHukEhtEiBUkjmiUypGyBPE5Nk0IIWN4Q9lji+fSwqVKqSXi5JJJJJFJG2sCMUbSTVIZRiIoZHKsrNWUpgQUppkURlVRqEVlGtqqJpGWWtEzCWWZyvrLnVmXoruJOG7uHldVcXdKlLI3cvF1oeursWhk4o5etXccrL3XDmO5U4V6ru7uOq555eY6VIbUjIkiORkjkkkkkkjbFVIGMS1WXKQqOqqFlRUpzUKiKVoUFZLChWnI02hapaVRQZ8DzbW7Ah8BsG+W+3vXZAG0NzSquyGyGoCbJqVUqqlSEhdThZpkWWhWoRFhGszFS6hock6iBGIQiVVSUZJihsy0RItNM3gKCJcwYdknCdx3NdnRxw0Lm1QyxEJQMWiRS0S0kwiuFWlV5YheetVEnTYboOOWzy13PLy9Ncory26Lqhe64Wqsd0c90K1XEcPQ8Nz0tNQVrB6xgx8sCbbB3y1A1ii7N1lQTerFBKRFRNRUTNpSItFBgN29EVEyII50sECxRvakSttXcWSZFRFORgrmRQ0Vhy2eUgYivHOb8dGZoqFQFfSlqhozBW05WHNzydfXHEkkkR3IhI8EQkbHbiXDLKw08wY+ufj4x0DgP4rxc9RzmdizFuCbbQlAj0uIRsL1Gx0zQpmsrewrLdVQU/gvPwDryaF0GiMQKOzwLEWG5gdzx4d4hR0ANWZmkDJiJddN9s73pJ56U2m2lqkbPWdNHnKGHIWLJFKJJHsFkSQ6PEk9tyIPHgNc8+EjoAkjnjwDcOAEAEkAJhkaXpfXOkrUxtEgejg7qTGwbE6eNk6cbhkB5te3eO8Hj1zsaHfO+uHLHS61nINwccKAzpfLh00S0FRTdrQG/Fs9ZQtk8K17u9tBgDacMs5AMMwQmB9c62xkA3gENmUKoqIQAirEVNo4UKRUgULAkQyIksHe+tmBYhRbUSULZErtxoI0CkHGpkvXjp3zT10nrpNtvG4NohlQxQf5QyDCNKQwKJPa+LIdJmyGquUS1uob5tNS1Q9VvbQMUFAi5VRUl8qQDJBR44bFGoS12mEC1BnCzJnYAQRw6SV+eW9+G2V9uOsa+rIJcaHPLjZjUYRpy2latYq0MzFnpwxSc7WUQrI6BlEXmIoickNhR3sYhFWd4iRJUkMRUGJJKEwJQJFUiirxU44myIgpqosU1LwsMyIxczlkA4GBy8MEG0311CN1mrlq5gEsUeTZIa0M2iMLUJDBy7e3t7einbXdNuMMyilXoXXYvCw9d0FVuXrchd3d2b0VR6+7S+G28crnMBwOlFtvhmYYxrtTPEpdM9gBh7wwMH4g2gHAbYHXz15JJu95EnYMnsFKFDqHIZ57EdvfcM6DcNpCOiQ4IjsD1QwNbsCXvcDtB2hPPQjaZO18TQbB4DmdAskDuHExByHebOvUOprYPAaonhcXqQ3e79Jxl80FFTQyg14XAt0G0C4QQ4AriwQKQURNRQgoKsk+EIWQSh4DYyQ32DQbc6kk7+IiEjfx27upNJFnnbjOA7yRyGB1kk7hk2khUGjxknTmTDpxo4kj0Gg6QlDWgwM16XZ08EYIoUJuHAUPHf251bjbPPG4eQ14DPO0yRLtgeOO4dKC662DWObdanAsMhJEjHZ07a6d9g868h5kPY6CgwNBQ4DYNgcBsOQpE0FDuHIaDQdgpgaDDkOmENgshMCianQ0HQOgYBwHXAbhsG2apOQcqvfsIB97wV/3oRUOiAIHI5Mdk6B+bbvsHMknBtIdzm+A4DPPrVDxDzPMIm0HEJERSMIkkneDtsHuN/YNB4GpwDuFB8Q2jcOJoKKcTUI48ByDqHrbv10fAOphsexFD3GxHUPjx2zZI6+c9V1tttvOZka9Qd4iTvgegmceRqAPij5LSWMpNtqrwIAjPbPBgBrV2ANQiewWI4Q9q5IWyHQNuQ45Dq7O0Q41BgY8YG085A6LEAnYMQWQskWd9aDr1V5060jrvZIM45YDA1Q4Iy9w0A6RJuAMpRDhsgb+H1VXZVVyo/wxvh3RBebBU5AQUU6QUU0Dphvd8ttvluOueeaSKtlqWy2a8kcBSpAZJJ7YE3BQnX4SWwu4agm7IN4BSHExJOUtls1nEnI2qH5KaVDVIS2LfGbeN4tubW5tsbaNjY2o2Src25aiuWuWr0ubRtjUVyrmi1ioiNYNHLXLY1vFXLUaqNotY1FFtRaEisaxtslY2xa3qru1Y2smL0tc2KixUbc25Ri1XptjW5Fi0WiixtQWK7u25ttzbQa0Wi2g0GjbcrmxtRaitFYqPFXKr1LrvXmqNo2RQ+JEJF5m0KiySRsRCRUVVCkRg1HrBQQ4wBBG1yhERESMQXCHUoCiRgqykURSPWCiiUhEAIqByRFRNyiSSOIESN4iEiqu0LCshJiiEVVgqrCEFVRgqqMIQCgsiSFkSQoCSPhJECVIqAxCCKkQiihcRQSgFBQpBUV3QVRa2RXgIKOkFSS2JJaQFKgWxJCVUkJC1tSm21aLWoqNUW1WLezm1bRaN5ttba7m1sUsjIJamklIbKUl9CdckradlBcjl2WQitG2w7DgyYkbbYLbCbOnGsAZ2EMOwIGcaRdbGQCQjGwk4sGmptTUq1NcKxFdbVlqa1KWnK7bS7uyqyylHJdoztojbRqxiFzsAgODKJKVk1MtJrWqabKmrRbFo2sWibNpxLqlKyam1y7WmlaZaTVrVNubdtWsacrFrtJbTZi0YqySRCCyZN7bW3z6trWkSMIiARVWCCCwAiioc0VUEDZVVFO1VVFO1DgRRUIgsREAOamEOhFMGEIO91LU3qI1ZATzUJksRCW2xJbElU1RjVra82TRRtEM1jURqJ9HW5CQWSZCGgsosqjRoNLu3KxRjIbUbMDawDfC1drlixiDYrxtuWyER5q66CqKC0URUBGK7V12vFrmxsJSXOY1jRYod1O6DGwbypuUbGPG1zaTBtG0Yjy3bsZMljQmSsA3jmBbuund0PK66G1BaMubhVHjdEphtkotod24Wxq5uFiZaIojUaIqTTu5XLst3doqGBoQ3NcxqNJai0wKCiSTUUYiswK5ykk1FGKNbGyUbV3dRsubsZpjKG50mYF3cgEGxTbeV29bbq7W2/M/mWMpIrINCgPMsnWYeyTjRcN1NOJJUiLWkO2EQ1UEkVjyWrREXEmNRAxVW6cp0o1ck6pRzurh+96u6JBV6hEOYcgpyiXJ8J55KlhpXBxCUlpprYi0lWN0rYRSNiMVojdDQ2wcTtDjZswywuONjWXIW3LuUlUscSy5G7gKZLI201YiXMxId4sV3YiWrUumSKoTb1jWa0kOK0hKokmkS7hajaRdxKlK1uZmrJrMiaxMdkju4le3ktEjzRqYi3g5SEbETvh8eZPTmJq7rlmRSZJWalrGZZcrEki7CVEoxNpRZC7uhOC7h4XKinpjyU8dyJ1nhO7PddIxO5GOwYiCGIdpNxCu3asckqBySnPpDnn31vT7QGr2dwq9QskPJHWhrh7qEmynrzjwfDNLIJHU2XCLLkyEiREk2JagbbtCUbGiVIKDlskFVoUkUHUVqWNtitxzb17fO91PyA3m3y9+WXKo86RRUPLwddXDy8jO05JEY2dq6Lnk9oknVIsIkBkSTv4ltFFiIpLJCYSFjEpJVRFkiWQhVEQsVSSoiRaS2BZC5UoqUuVDYVQICCqEUMCISO3ZLYt/FraAiR19w0GInHkNahO4UMJ8A9t3gNoQ5SI4nQOkG8pFDgGSHydgu4cByHnfofIMDeb0gdQ0MDtO4Zc1vIbwwO4UKFg4wPBZBuEyE7wbYE0GBo3+3vZ8AtA0sOgB1qKhbcOMKyosrpKGtsl6wbUodE+C+iFDiiTzRbhvRffeHwiItD7uHdW4TlTklQX2YwPDu1onF4dy+ANn1euhkrIqtTXKmNTJQQxKk0hqyzVVWFT4T10iapRET1gNetttnc+ZkU8TjvjbbbpyplUc+bZkbXhxx0luVVFDgi00hSgh138PpkUTUTU2bSr7bKiDhVB3wpfLi3DKHRDo2lMJFkkcCVUIEvsUMYNdtqrxrvmJcxbb50Je+gOgH3Y9734kTTTTUus2g93BcvLcJyRkaiZAUigEUSpAaaWt9cyJprlNTda2gQ+CBBFcolKrkkkxKUpg1YpUVRTByUQXGJFTKCjnKK5fVB6wcceil0bbKMxJIXFKqBkVRTJiXkVVGX19RVmQgUOuBVUfHqyZgSFZuybFNMY4VEUR4pXhvgSRYCPE7377sbNAasRmQQkRNVdNxU3SapD2AwBAKd+PLbfqmko23xlaASpUjjig3tJBJNXp0o1NjhW5lhcaNwG9VMLjAZug2SS7S7jGNpLMXQsmLaLXgbSaYwwwBVSMAkj0VVHKlXJJqLRSwGZeedbAGzVkXeRjZdZNoRELZLlGYpUjcmERwoqGLk48d89985ic5mqq9XcTeRiFVUhw30SAcFFQwZcZsvyfZpI0klIVCiwUULIr8O1twIndunTmYzpbtNgBAi1ZsykSZw2Q0ZihTf0jdMYhjBFnj6WeRvf0Ln3puJjk5qqqp2pS2zsPO8TYlFSLYUsirIqrLKtRbV+m/08knsHcHJqQ+huWnnU31gntvEPEOVzlDMAQAJmBACCNe+s17hrydA9cde2eEjchuGBQoZgdcGH1ZnnqGHeSQdyKF4qHYNjXbrx1kOR1DaDv8L26HgK7dQoMx57zNeAeZIczA2SHlBKHaUc6uTYMDraGm+weu/byKkXnjPhbWeLSi0RgxPQAyANGkAQyAHAwGBSgwGBZv0kktlU0DUJsDQYUg0FBgN+obhQaQ3lLIG+0Y42IYUNgu0iNBTJMDvbxEa7bm84A6tx1593p36N4KT3cvffObvg1DhcvVmWAVgLIN57BqENnAVuOsIZQ2kNrsDIOskhTYFcG82QmpLPB1DnYewbSGHQ79g7ag6QC9Ox2DYhQmS9N8ncNgu281ukbge3p9mt8hwe4gR+mzLwwbbLvMgiAGd798cXLtt8J7YD0FChtMB7DN3rcO8ke86SGplD34TbsGguwXpMDmiN6Esh4cTgPa9Ui7+/wcLrr642tVgpnnPJ42lOWsZ7zoMabaTJO5LV4JPNFWynwkjQULKDURPQUPQee3sAZ08M57dus9gdgxC7XAeAnqTY51wG4WQb8BzonWbBykWQ4gbEkedp03LidtGgW8WE7Z56wTG147yOenbjfj1oOmhPQchgzAoYdQUNBQUKUpubGgyaDruE3ChxKHB0c6DnXccZxt2Dx7NG1DuFm5zZztt1b524aKQIAQBADsA1RdpK09a8Z6ZpJKLqNKJ73vCy7y/TC+71dBXVCARgShgCoOoWNNx6Nw3M22SZeAN0pFsVbmBkEmbe0iTmkESOwcIQ0jppdaVXKBximlaFb+WOPTeqiry38OFXZhCSRNvWSTvwFFnBhG80Ggybmx4DwbhsRtqYbBgO2g5BwAcNAHODcDDcU4VzpleQBwyIqYQ3oc0KFkkG3N427zs7869siaCcno6SEhqh169N+3EJtv0Dm82dw4ChtKiGay8hzt3DiQjjW2BoNqHQ0EngLvBwE21rjLw1131N2tph4kkkiR0bzxBQ75gX11g5REFMKOYCborUQkBhEkUkW5bG0bO7aLbFRo2qLaTbGrRY2ktFGjRbRq0aixZLaja2K0axFUakqjUWKitiqNWN03No25rhHNXLRY1GoiNsbbG2MVYtRtY1WDS0VUgtELS2SS0g6xHyIFJtbaSggMzGDQmrW/Era2A2KtjaKLWuJhZayVKoCi5olRTTY2uQWSq2K1G2LWrlMkTJrW5tVG1XUUaa3KsIttRaFsTFiJQ4kRJI2ki5EqVEqVEqVEqQSZRprAkkIlTMK1CgqITOZzMm0htNIxRQAVCYd3EpMaSyUGjFSRFy6UEAUBCWIxRko5cMbmuQYyY0SlAmndF2JBqEE25wEtGKQiLJGNiSiDJjEHLpUgbShjMxQmATmuykTAhtzXObhkExkOW4aRlJyuQYQxKaZc3IucjJoxGkJJMSlYCJCksBBkzu3DBFFy6CEXu8XjGTCYuu4gNJBURBy5soQyuXZSd3EXK7SMSBBTuuwMR41xDFpNG2UTBJktUVooyYqZpKMGkyzGk2Ci2IhpJGTSMwUGCESLSQbRsaiiwhJrEUURTNRoK7uCCJSNCG0JFkmIJQakKoxRQmSxRk1FDSS0zGwMJSDCBoIyVpRm0a2EsY2xWIxGGQaJmTBJWAoEgtFiIxgkkjEJiiQkoAKIxkJMmoA0mUyUzSaIxRVGI0yTZMkVCZMQRIGDM0mKNFFSREKUkQhGoybMUsgRk2ZERjGmIkZCmSRFSMSk0e+r3v3Xw3poC2NUFFGjG0EbSbRBtFWDVFoxbGsVgxmRUEaEqiikjGyaIslrGyaiJNjUUWwGJLY0RpljZNMhlBrQaSrRUBbBtFGxFoTFiNtGwRqKiKCyhjaLGQqCqLGgCpNFEmijSUajEGNRk2isbMtYkiijUmxaILGDbJBURjRlNUW0mxGqLZN1eUta7eIi2kTRBaIsaMWJCi3KLNdrxtJSlYNRosmLVsNRiyQtFVEXW/DYm1iew6B0D4PBDTj4wYHqRPQOs4B8XeDAugswwLLZwvEkiBvtszgOEC4GuvjNiGV2Dk6kYWD4hd8Ch2nSch2k7AwBliSznqgZNpIjYL1kKE0HKQcWSSDsA7K2bd3bhyGNr8Z4DU1z4zxJ442CWpEcUDiZyGgclkI3Qbbm1B1nkdAwKGB8QoewNw68u97rnHS+JwE0c+DfpuqZO7vOtyAS7MgHAuZV3cOYBxy83JswASH1WCZtJJJEjEhTCOiKHtNuRzDWJDtKKtZRJV1dlFFXGwFoTBafJ6KkuV60pgGAG+nZgOJA7BZBODIsC8Ij2gFijYxsFUIKnZ10IltedWmjegwPZK1tJOAAAzBfaVWylQA5ABgEabJzQmY0ro5687tgDAcrlO2u40lUm2Wm3DFZuPEKhpfXXTSLjBPDMzMzDMXDeDDOVd5QzbhkLeHPnZOO25WAaoi8dtd4R2dyISOZpIDEiUEbWQrOZAINiCwkSBqSLCQkNEQkaSJYJDy6UiUHJ9UhXp7V3x5vWDRSTrQbtjTGwapqrBqh0uE+Pjzt4TlbRLZ9bieOEUU3r19NXzxQgqbbNbNWQERQohimiEEaYjJImmimDSgsowWQZKaFJgwKREpIkbIAmIwhMMJKaSSUSkJDEKL8383VisbRRSAxSRIokSlASpCZGyZDGmjMMU1RREhGJTFNKJqQjLRtRMFIlJIQijZShrAmgiSE8tas1VUtrzbLIhGUUYYYhGU0KgWI0ZJihtEQIpYmZiFiTIA0YKYMQSMQmGMFITIyKPPEmZoZKSiJtmmEREkUtkRKEYC0WNFQDCkGiRGjRCJUlBSNssmk0agk2SzEQwRJIRQ1DYiBSgSQYxlSmWWAjJJINazNSyHVDe+6S0F7obE3hZqJ4tz4NUF6+3wg0HYcaCZfjB8YknZYBKpJBJaJVSJIdR6G7f3nb3mwkj5e3n2CO/vXq8mwUUPZgZbqewd2sDaSaSQTDNm0KBEFNhRxQIgpzFUDmoVeQBNUNCCoQUHXKIuBRiKCiYFGgBioCDXCNI8IGIlqAqAaxAUUyaA4tBUUyiLnAK2gqKagqGCBAggxYKxCySKLCyKliVEgikQkZIiSR1SJIOsAkahJCNiG7EwJQlJBLElQVFiWFhrNtqUpqaLaspZStVpIWWVaiPqsiJGBS2IKCQRYgKkGIQFQCyeJw2FFBTdAABUxdKqopTEEFBcHCgVRUykFRQWAQVAREOHXjXdu3cN0d2SGM9Le/LKCUCKOk8b+BcKla9EIuQkUpk1u3BOKQYz3e06Ye1F1iHI3ZiUrTUMMYt+UwTSnWZEQkYHwlNcyMMiyiZAskiR4RkgJA96IhI0pEJFJCSkQkfPOYESNxN0EkSEMqwUOfb80758YcTr5VU2VFQqnuwdg5zZkxUvOLcriA5ooQAuKh1dPCHWSAQwgu2sjJIidudjq17EURSBx4l2aqIketVVGbQ21u0keGgBvAFkAZ20K0WlAIAMPbSMV5TeOeAuJmYZ4shIyKERERRIRUFRhDcPHiqPAwnOImsTka3xwAYxOgqIpDiAVbXQlaMOZAxK5RUk0hMFAaSi2WbKgDMeXLRPPNusCJI7cSRCQxEEkEMxQkSM1BAhDkJkmSz2sFboYNtpJaYy1y4RRVUQzE4aKpUUKEOfIH++MjgHXbXq155zMzEnuBkCcJsDjleet69AaCqrDL0s9I7qiuHcKe23iyOqBcqgYB6hQDROoM7ttZcxnKKoPWqqikDgDFBEMaZ4V4aSuGIYQVFOoCjrwJw540FF5dfG1F4yAGYIk66QKlqigDmkFtiraqqKYRIqKqGIgsI42CRqVIngKEjenvSBsEoUotkOZFC0HFA4KGxXFI32MkG9Cb2RG9CN1KdABIWaSRfUk6yJZYSREgIQFFAzDvwqqjqGoRExfUJmo61C2QSR1oCSke0P4ef2HT/cv+G1NT8pH+uX7cSj+Sr+UsI/5/uf9VNFSTod6q8S/TLBH7oqmOPshngYqGNat/irhauxYfw++jE5Ue3vME0w3Fn/Mf7vp+J7f2+a6nI86t6JvbXt+Hui51/Xbpx27ZcfUIn2dh3UZqI/0UTzE3H4O059Ovxx+mp4wZK47uJD6KHc+EpJH/yH+YbfyD5RDQGfQbes4innY8YnxfH6MdP7/RfLaIY6IaqZqoYMIoqMkmf4ux6fI5na+kilhy7OCNB+ljASCi0+2DSSEJL7vKJ4LJGJWmAuGFV6Ionak9o4nH1MRCbVODXU3GKkqaOZiCfqR7jT/UnvXlCuezOcaQhoVNI6+jU99RmKfWnvpMM9Lh5S95kNIGLiiElFYhAmXN7frRRo0e0qzVbbyLLa7mSs1Hcw58ExNSoJ1bKP4ScU7QVpv0lx+h27M65Y+mkSm/2SpBWNGWk+3zklyViqx8lo/koPyrPPrrWqOjvu6rNXb7YONZObryZTXvPcT/kZ+7+CSEMdN8I+ng4Tf1XZ7mw/0/03IrID/iQf3wLqlkqASO11P9siA58PIxt4B4QAu22hNgk2JNjxyIbSGXBpJw8wYi2/I2Nr0qvGvTRt41eNYtraqGVJJpc1lzc0GrEWwfg7+D9X4VEhNvOnfajO2HL7FmXbK4wRieTSEzUNKcDz9jX9s1mx9RlTRtd8qsTrt9TYb9/OrWP3tYTdBmbl5cDfQ2T5l5weMbR7kT6NHm/zTiTT4jw0yY7rWX7J3nUd64n4r4GuuTjXjgnN88nEWXTY2uTcZcse/jzvSveoW1akVyvn9mei73253XgVV33vnfFlmKW0Ccyf+oNzGfF9aGXbIoevv93Jiwm1GqjJSDWTZHCN6cKRL2V0ley9uTZsErwgwikzh33JqxLT+exo1B8VLRlBJbFzyiiU9eP4yV6CWqY0sZnweVStM83xgy/Ub9uSeC/tXuHgd3XtGc32r+SlYiXlHH4e4P1eXj2/6fUwDl6m6/lYhnECaZcoJkyZM5KS97gk3GOHuajMqFCU+xcX/S+NP8qfN+f+oZ9ezKxu5HUzwQkT7jZ/MJ93+Z+T+L8P2P+T/x/tOHD9fnp7Uh0gdRgJXr7aPA4o8P+q8GrztISE3HW0eoFrybQ45/q/4OB52/ii5+poLBhToibuHkZOc2GBMGAJX6JBPcEkhwzY91aDjib24aJEn/W/5P1Dd1hpB4ibq2GygNBj9P3fjFvDu6BJJL7KecPyUm6HrCB4JQUBb9xXv7fZ7q9s+TJRnB+Bo95Ye9Jdbn+Wqm3yaYZZh6ayZtC5+yrHM5jAW7zodZ8Nzg+q8NupTZZBauffhs/hucMgjsN6zGIZxx7n/w8w8Gc4tP5Qg04e+APfQ3bY/6BPva1uxpNQKjo9/wb1hIkhIYEtu/cj4JBAf4+wrz94JMcF7WbLFEkAhMjzH6CLClwN4BetfE6jz5Svpo2mRoh48wtxCYkJPSJ74nVyZOdfH6G+lm1+gNZ1Mz+vI8Q2HZkSYuJeoH2Obf/31n0RzswNyhKhJCe4kkJJOd7YOBC9cNve6DiBZoU90s3rmapPP8qnqDRUPlGEhAYRYRCAicfXSfL4V7Lu8nSvZ5+pT+X2HqfkPNidpyJHup9B5WseHEcP3I3O0VWjxSSSSBKjAAEvtpXpYtb8NOvycz2STHWRg9b/k7/QVXPVqm+aXYdZlJXPEHdG7f4OG6P9s9OZ3KnYeOZ1lV72jhDQtiWW/V9XyhyfkzgKqkSepaezhp4vfNToRiEYk7w7zY8MbT7Ag6x3/x/LafmjkJAh2j62qfIKhRRX47L5sSQvmUB9XPo5yQTblDUPfLxXUu3xIuWlwkwb7eK+//Q//p2kWQkdTQLr2m64wmBMPWQ7n84bAmrGH4uWlVRqXdrPR3ZcDCJj0VpeC4QJP6qM1kkwsZOmaK03tunD0xuttfvOd+oMNlIhQJfGtifJ7QKZNCHOXVSSSSSNw1BmwJ7iy15ymfNPIM1iQi+6qWbHuHi1febkmmgHTPxdxIKH6Y3EcsmPH+A7OQ9DG5/Rod20u3r/Xo8IPfc7fZlPp0dGBc5TSTTFmfs34xmv1bYbCXrmYwWP6R04Zbh9Nbl1O2P7X/lxvv7wpohxYlk2e4Igd5GHUfeF1z2l6T9xPsuhJCR/2EfGLNHKTZtehYdqlf5pyymT/0nc3azUkoKPF0pCg0Bw/6nll875wvHUl2N4rR/6vT5d8T/flohebu7iB5hqrIyEEKn92MSf1UgkbDuLjsOpD4HnC75RHd+XymLbhXxOcfhg/KraNU/5SHb/ToweSY8/0wNtsd3iHlqc+2Z8lddkVqz+V721DQ2Q46de1k/7P0n+EAkMkEgW/eW+jbkwhHXbpbk/mvsrabuOHR+x1Dh7lXtMDxVHaKqJO/s4sMdGSQcRdHdR+J2es5crMOcIH4nHxuLzez9LpJlDJv8v8hx3OLfchqATshwdx2xYh+7w+UKELKCKHuqw/sOwxSvVBqSTypqcrv5ceuefhX0T84Se4jaURL5K4lP/zv5U/D+OmEJruxwVENSb+5m/NMrL8WUrM/S71cX5UfHPCW6l/BN9mWb7NUqZfZ8952ZXms15ab8GTMJJrCiQ8pIrpBS4lz0RojAjUZAXMCvnrpNnworSYh2z898c6H80OOc6hpP+rvez974WuMnC+VvWM8x3pv1XAsuYe/8/RuhsKtLyOGc5SfjvEV7k+n43/30eeasnRJfZOXW8EGdDjyun4SqkIN0USTSicYpNQLvVbp5aWmTkRm9Zni701i011vc3vb6R68qviuQCJJaZW6SRGPTk+iM5x4u48arEkC/pu7T4hr8X7c9RvS2HvQ1XNE171Oj1VX4KGXweSijtknTLsc+XkJ17lQa0GwbV98kWMi+r8j/yZzw+cv06HaEhcaPSyyUvL8NuUhws7tk7wjNcqYgczrDaPKC0Oxcpo8b+iXsVNNP6l+Ec5h4sOhJAunx1rLZ/Dhq3ZFpucLdtKvqbwTV/J1fzN9/7ENmy4Z2gimOEfRbUejm5pnc4+a1l+iC+UjfhXJEljP4RK60tpaUIdUXAcfAiUdiLokie8NCZIUO4kisO0ISff1SOHCngiQmSxad5l9n+Fj0Nv150Zdzgh0taebVajfUNLaGYPPEJV6nfrkrN47bt8KyVjSSQk6QbI9ZB/9iHorvUn071dx6/65mtdboT3lw0Ji4y7Lf1aNzxRKjzIztJUpvDqlYqoQi3LmYnMFQeIdWXGzqTrSzwljz+P2StYrAkoMQW9Y81+rk9ZxNqz1jwhnSSSlfe8oLa52smqiPfaF3uPmsS6zJzmiH6y+EdaFIliQVj1xJUl5QEJNq44hCxdD+akJHnbiQlSMZpQXqNpUlXzxmLW9E7ek4P8js+Xz+ReJn7U0KOQcp+n5cnyse+sKiOxURVWxjPvVqISFa+iSVyofO5mEMX4spkX8inCekz7054m27+x5GWh+3x+aWp9EztmIXzuqfzOmLxi1rvR963y63xZ4Ve2E1cL9pWrvzLL8NpTJFQISQl9iYJCtPHXK6sdJolfj+zzfMq9IwG9n+B3nUfP31SL1fJSoGSpLyZo4pfNkTxPWtlEtnbOzmkRckwqNzxd4mhAvZgylEOjFERI1TGklOe93lJMhCsjKGmls5JKHHM9ojzd0Nm4/XHw339NAzdc9ihhJGEyVUpIPMoqL36cTxK5ev3Fq2LVXOjte+LVrCra4OPtY+D0cgoZYJHqTHtu/1rQRTKcQWSSe4PQmQzv6Qv7PXGy3v0v8s+q+ev7VuSdGmIgkj8iyydqI7FX0ckksnlHtTnlT/fI5rLltFoduKNUNCzS3csgv6O0006eqAwglN3dyy/VF4olileMytHqii61tSczkh7z0X70YoJ7Rkm+K1n2wThfggestokZp9nsmdGWHLvPkpN7pvTJOF6P9jucEWQ1RaPnFknvjKR2WPh5u31mUpRGVU10Oqpvwx3ROPoVOGtPq4WnLgma3o/r7KQF1n2fGDCw+k85CE0/kc7fVyhp9rSwSJfM4R5OEkIhe3m5IMJh0yR2o5Rr4HOY1E3Hyf96ZvrQNNMTTM2iZjz278/NE1weN3olOcpd3nSVJ/Q/hJ4/njuUiVfGCyyd+6bpfVaJUnLSJ93O9FWQw7LH1+Wvn18VOtnK8H9tSlkUya02kd0yvYuyGPZ8so8Ieyap4OUylE/bn/Zq5enyTr8QtM5kjhyjkTCkEKh146SXdOPZcudKTKmYqZZVoTmNwPiSainNuDQ3vkOpHV9F8Z9VCfpVpQ4adrpN2r+z9mhZtETNI4EGO5js+bvH53jGrhfy8+dL0/X4f85UzpiHt6eV/KnPw8LH7p9ipfIpn2bVsqLpGTyqtf/378t/PLL9OtDL10OAVTe4TtyXu8PfwJNQm/0VeT9NfbuzUqDZrPb9eb/IcClyQU5bPCx3YhQuJ/h/2/itMRR6bSg6uVEJUkAvd+af0d2MDivEoh/3lddUG3+x7D9h/4L+TrfRNy6vLexIYN753sCheR206MJJIHOM+uuEKvT9GNQDsn0ZlBgC4aQpYhEW2FBNbvVkI3EMwPn+4SPVFl+FPmzJr+SsLCyDVlWTLeb++9P7gviTyj72ypTYyI6GOM8ZojeJBP62/pCww304AsFhuRP58NRAtsrClmmKIDLF0KdLuJm0paiywpaD9BqJhdjQmcTjD+l2PpIj45UOu8WyLV8p1Ph+s8H3Db6sY7Cw2nHvK1Y7iiTJIEkbbOwOhgsFe8CfPJFxCQTrLOmgaifUMDwXgHhnr7zw8LefgtS9DNtsYW/KQ0/SXfZK6v5P35tYZVDIKxt9BI7qHZUSSzQnhoZ3d3HBQlSnbG1wkIbSfRk7iQ/TnL0Up6h/je/jTDH1pkx785Ht9tjceWF/LiZxX2HyivsE+3tg6KeXVRNCQ4sKaZZoPaL4jQ48StATrV+Vis6qk9j3nv56rehmS1Vl4dvpOpYLdFkYYfy7JMdp2/TonubdJrr6ttWnOBnbKPMpsJgPqyJ47jFqVCRCni70o3BheyKGVXA+PA3KevDA9gHvN/fvDiG/s6x9tzuTgVKaFWSl8JT7fZ9RunKyR8e1fmuj7DrybND9Shuh3kr24uFAT1iQNhscXzeHHQTIaYxoMvrCw6xjeOrt1DgF7jT5YYM8m2m1askPMbXtzbxF0Ym6qDSdkf/UsaI9RJBoNiVraXL/wPHj8U5cpHwqxZ9bMMIlSXvuopvFGq94daBjoX1m1aW5EoPgFHyMTfAkTyZw/qNk9BEfP9MmrqfA+f5u9zuO7c+zhw5XCjHscCqr9A+8dH5Pynw4sWI7D5mzRzLLLITLqrEB6EBu27t6QQjOVhFfbfvCAsaiCixPOZ3xMQstu+MUp1e+I1SH9qgw33z9/+X32afY2S2sZ92JA3yEhF9H65+H2RP9FuKDBbgD58tCKhWbyXkyOWmjggUDNXRCDO+39t/QwtiQjPwHxGhhO4uQkCLS2KuiAIpHPEUlFAkIqQsiSkdvAdwm20iUqSHaihVHiUjpHr+WNBlRNwUFKvCkuWC5ZgaxhFLK1UN6j11wNc/K3153nkEZGPAYFkDJEMCdqCTARqAUCyJGuaIgp9T/lhMMQ9rGCQkPGII9Ua+HvDUkDSSSRKqyRfHvnXYgnewkPh59Z52DanOKXiG+jEXdEFNFYJL32h0FMNG0BbFVRIvTWh4gACpVGgEdmCu3zg28E5wHjjlo/DugxAE22OcLwgjiG6LwMFImZCGcXYEgJlVVFIG8387VzFQkMKqopAWQhAJExZEvMZGUSBHX5D6fXn2V9dq8SHUSEhYgSdKWxD6RKkxQkRChImI7HsKAcEdjmuhg9h200vp89ZXGT03cUMGrou/DGInE4MiATzUqURVcxBfoA3JKU5FJBboSqkLD7PtR/K1Ui2EVYlsBki+OJ/qsdCCRSEBSzif04+n+50U/5qhH2urtS0dtC2B4vw7CfDwtD+RD5HBfyM9mE+7gA4/Pr/JesT8349/FN+WEEFfVccIJOAsuXCjlywJ6X1xAJAH4gFBQjUUjFC8JaWwyC4+tqOtkX5W2kX6j/OVIvW0qt71e7UsiMjbeLsPFuYo0VVbHSgklsWyALbS22f012IhIVqyQJhWoUUkSKRQSJEVYEFU8qUQSPyqOkkjT5kkYiJ4k/Od6tM/c8llKt6bj5lgNXKlTNd1xld9t+v8M4nVLbVFl/cmf2FNWrYxkT132+OYxSs6TMWofHYRqpPq2j0R/uq+cdOHKTFoqkUS/wNKfo/0AoMVNt6KsuMsn4XTovSA9SVSFmmK+LlaEXlFVYMuO2FahRn8z3fJJ3NEDbWlJ9NOPT8Pr+IxknmgXHZhg0vc01V1w5hiyjkUUzm1CasXUs9p504pFVwhjtBE/ygFh3JO4kZPkI2kIMfFNQDz9jK/aQMkRCoSDIhIr/eNUwjGIjZQUOLQqbtyvWUQjFIMPOBTUYfY5JTfHOSApE7wTryOCCEImpBD+cgSeb8Ltk9UB+nNJ/bEdtvOJOAQeLI4PgWlsLB88I9R4s3B1uolBvJAd/rIXuCQzFSMAkgP8RwTqy4J7RSYLaNLnF8DkIe5eimIEgD0Ko1DqU8x1PwtjHiR+e2o3slVOO+j4vfd/WqlfF8zcfqkgEA8Y1lTSMkjEnaQ0BJPb2/vKP8dkCJp71ho94dQD9wRR6xikEkQZWX2ROK9RUpKjI9kB1DVIh04RJADeansi82d6RQtIiUsQuJUoI6RxLTeBlV/Lh8NodTVUSRiRiehEttqpVwsTBixUnEkj7Z/irEGuE9n44EYBIRgpIAQSIpADceee79vLH3Z78QOoLiMgJJI/cwqNhttjezEGlPGgrj2RqLCWRog+kgXaJ7guw60KgtRSQA7KPdkmjTmGRRgbYPO/TmegvB8VEnBDiZhNQ6qp9Hrv7pzYViym4IgdiMCsQEEyJogSVWWzRgcBKGCorVVRsMoIVBAh7rIPwzVQdVgvsNOvBjNnGU3QcQkVciwwcRfdCRFGQdTl9EEsNDcnXfhKUKrRGkhirpFrm7SUqCZiG3HVwdZTCYKJkdYr2FqhtV0hqQ2PcrKP5h2Dn6/8f3MWM/um0+2p6+h3VC2MoCzm9E/GEXoIfjiOCHx4kH8hVgdoJlyYDy5fD4pD0Pq182bmHXp+d9s2n7P1fd99rw5gfwJjOnLjyNN/Ke3GOGiGMhmxIpoVzwcP5P0Qn6LUEHqP5M1Rkf2kzCIaQVAyXQZc4MJgS9L1ANgWafDmAISfoHViJJIjLRWhRHcQNNdsYDb2Z5f0f79TgfunFVVFJw58TjmhURT/v36nQFN4lHzxm+uvuw776pmdoBoHHJBg/CLJ4tjKj83MuEspsMMDMZ5qvHjns353KoqculgbVXA+c6wQxYBqqqiluqqtAbKq7gLrQ4dN/SGHZVVFNwBvcLaqqKUrTIppDphVVFHJmztqHjxB28E3pISJv3y8/KEv13mFQ5jQYSnsn+vWn/gZqjVOpVVFPaJj0CwP0Qln2D8jGYJTRAlBQv/5YVum73ffZlkIEPcBM+kg166CCQ5qqopD5A9VCWqqinzpoinmmEwCIKSv5wJyiDZHQRi0+4VD41BO0s/WZPMQ/jor/OsjymO0NhDz/m/BV/Qt8a+LQ0+rtbihSi3387xuhBjBghsi4PuOGcv3D5b8zd6x+QQxqsDT9Pbf2T6g0X5B6lE+Y+08DWBOQk7tkTWx0nVMwVZeIkJvlx9JkIv1xETkUtYJtKw5+z6qt9ykURErSLX4Isp5BYA/gOFgv9X4ECR7vkhOx8RE2b5aCpDMSJwqNDK3yx8ab8+/Gd8pZ5IAR3FXGZRajiRYkNZhOm2TvgzmyHWzSyHWm/XHbjJ3naQNSBQoULJCiUKE/d14vB0WI79ttbdcmqZphhgZitnAJ6O2mc/tuTDaye7MaaUYBK/MMwLL0UxXPkc9wIgpqocLu9953B0U3CJiaEBUN6qqKRFSjIUKrY9koosDWyjxdwYxVRVKd+W22m0gbQSmNMkkklBbszjDTQDib/wh2+Yrxuw/AeB9G231/ru+wZ+v9ZO7Sgf/bSL0ppcmqF7dq8VvGqfk2p1JU3zfIEDkWYY4SildYmCWSIaVCLIhKH1r0NjSOxISQKqm3UkIkeK8t3x+6vwgHm9Oq7fhpWkhv8/1CGvJIgu/52iPmKarMDqxWEzlxvJxAnJXAfed+P0BHpIxU3SpMXUd9L3P0CTjeOBVKtltoTGycCoUjyyHrFUeaKvy+Y+RNGJ1HEdp5oRkynkQMKqEU+uw6xuj7ohR9ugN9GTSOmXFuPIPIOswiYgwhCSAQm4RAC6cg7KW1jRkQTbDg8MZ3cb+/Df9fBR/xiWHLr6/nCd/UaUWinZZr8SFUTvT434r1I5UkHyKX+KFkc1+exyXXQ80EZk7UR/KGTx4fns8iKU7swjM1FxJMll5cIZIhZH7SCUlydXaawTCnJ+OtRImkpYaXQQfY/ouGRnkZHAn6jVEogOg/mlpCKxYmalHf6qMETBoKnoqI/7YGAHuP/o3P2bP836s7JK9lyHozMdWpOzxYRmaP0A81oA4/Y+vREE7J9aEIU4JyitSpBiU61NrKfi7MWVKqoVqDTQfoLhsfpNaklksUdUOv5TiUdLdK9LruwcCPxQ+6OJmGXp5QxgS0YaogWIQ2W6/WcB6aNBlDZFB3QdCuxcic+ceHHx1zkGVx5wc44GmmTMszq3WBLgKlSOUZWJjELeQPE74sRJBIeRNI9rb10gJk3nRu8junENZAiOrO29Jvl6wWEHO9Hqevs+J83mONo7xmffRs5F+Lul3lez2Hpk7PgUHDcEiN4+/NIXlq102GDiu7bEsObJEP/O1U6g0NWEHxB3HwjEFx82OqxFgIq0DqjPe+RdeD+s2WCF/R+P8/88cjP3AhQ/poss/hjsbwyGm0234RN6aH+h0fvkOIcvsctJg0+QwVzAYYzb7wBAETjLJNiYzNojF6wfllgrkmQPIcK256/xqTYO/IdkjoO2/XjDaj0aFne88ZSzqBlpKKLF7g6DXSbDDDDEp+IQaQJRBCySCWSSSoSVTYKmo+gF328easCyiqNMZVBb7gABps9FUzv4lGihu6HDkYBDNHI0veqsiRvBjtTygo49TnT1CSaESQKiREWEgiKREiUsLZVoSwRJFkkkiRUQtWIZ2Pp+d9T5GYwxYPq4vqp/CfGPg8Eth83122jlTeFnS/l+mXjHTn9hobEbHZHQ60mRg4iWlBQ2lJOB2pYJhfhxd/ts+WP0dV26bQPjluxBpiGJUun5H2vZAuLA+8Mxw+7NTPhQnEvxUcQ4ZnoqUBG9HjAVIND1eV/azCuZvRtO2GYumEaJwY3UgPioQ7jjQPLECL2TfjvPPMchbaTgQR2k0lmhckSoyzBSapiDRTDGNb+yxT77namSx87xDnr9DRwz6RB/Wjan45HX5TvFZu8uUeOeFUFUQU6GaUaNOa2wNb8vwP2Hfq/Bb7lfKx9/rtZ6V8dFYbw/n91+9TElsFNA9qLaZDuDto5HLzH9Jg7n1NdnjX7ZrLjzQJxjy8lT6BVLdI+7nXXe1hiGc+8OmE0KqpEPD+CNINnHCKIYc8gf8jNudhwXaRBRxySLgFuqnxn6oVpA/ERT1cGp7IlR9KrgK9sDgkS19vFT26iGh+sIGM/2P/DuN6cfb42eYhsfnMxaWlGllrtKTJ9n26dVPukRI/ERe+bG4dbTHbk85DvponaXGwkxgsspooDv1m09ZaWT9RDbI7ikN2AioYQkQzZBIwIwVKMU06rs+bfzPKUTlSPy5TeP9qrZKjUz9u+jNIo0K4+hJG4Wg/wDZHdiEUI3sbVaKxH5VsXi/Cbvk8GbMemqTa3utjrwvG9atm1Ii3RtER1w6IrOGRC4dDEd0+Tlda4xbpPZPE7qqmM2z8WvAszD3Ivv+Zi8YeJlbGC5InYyCgsarUgcQVMqe298zNIkqlB3zpKVXR+uGHwVhGaMllkOGDNzbJ1G2lCxGkgr/Tq7MZajsWytBkmvPUJwQOUe4gtrAWiuDSxNHIWcTGJ1pVEV5VU+WIW0WmM0N/FOhbZ51ylNpBD0IJpqYJxrnSFuHCxa12Xzu/TVv2OWLdNUIyCa54GbXn2JwZsXKfgsNqKxJJB02nw8Mw30bOcMPPhb1vvpJsILpqG9MpDSZNGl+RJmo2m/GVSVh3Qk4DwyyK3SM3bSxehYsULuVkZl72kMgtjKQHIecq7E1o3dBWr7O9mHao24Pe4dXT1XaGXTE2W9aO/SmXoy61DMH4CkJVR3nsZhs5vKwN8V64O5NdXlZZwcY5mZddHTN4NKOkQ3fF7OPXfdmCES5qp5N7xegjznha6vODxh0ToVMnswmjtnJg91nlj4DTujiKtMcQyHBSzqEhUxiq3sQcIxvPBQuoJhMEzRdi7ZcilfVrcijqca7xSkp8GDhxmXnur7OxNRagfYovcZ3XWdHOzSiOk+XqoVyTTEFni+9DFQrVUMQ0QbrFRYiyFoV2K11BNj77t3xDi2cac1eW1L1OEr0VzWk6w25KwBTpUOtHMIb01sZYTZlmzWjRclRvdmtUgdaMDQiM9LO9PjfjxzLyvEaNPEgEqU8Ps07K14exXNalb1i63mla/JnHPE3i4u17wQSeC0ieUQSN0aw7AqAnvk7L5tNc7UxaXD2qIBIzm2msjVNm09tpVLtCwxNaa74zjDnzaPPplrrNy9nh62s8PqueRXg9Otx8R8GIT+lXvXVzjeuczGzOudPK5WkHDOkShipP3QqG7UWdX6XywegXCe9DIPEpCLicQujSfGa5DL1AVmqwRrqFx3TBzl6SxNifKkVok1B2zUMFQhabvnbgk/3FLZk37qNaASK7couodx1bzZ58XzLO0wrYOZwVHXimWCFNlrXKHLZPdD19PGpOFL4KNVsxMTeTb5O7snQu6c3onJpS2pXeeC75jkKUNsGhw0NBs6Gwbg+v65+f71K+4fvM1kPFgUXA0GOKDN5tLL0hkyaTTDSH4KqKQh8H0gT71PMtgqhsAJjp7KBQk3653vSRrx29J47+QskRZBQqIjVVFNsOFTX8OlBsvxAdN+AsejsApgWEAZDG1eM20AEb7xALhrJ2m9YxOiq6ZboistSggm7DYyhgCk3wq0xil+CoF764tNgaPqUQaz2kaB0CwR1sfGyQao94kRI6yPCIiBYQSO57Pec+ehnvz79dkT2gDhIO3OJEdO+SJ6kkQLLEJHDJDkNvXnc1KOhEFK3t6hrcJCQkoNgRBShOzqPLurh7PG2qMoaiFF9ighJwTFT9vfzq/j9UCCK5FzHQp3zePIkrMg1IhC4jFWN1VsnDsXEZFdvLfe3/JeHKL2qukJdMZwMeDG7GcHiUa2/tIdeOE2+9QjBE8BYnPFGHVuQnR5ItZwLNgdNVqq0pgJr5RZmRqAjQgdh9geSuuu9hBF+jMFKflGoXdc9XmxVuEKiE87OJyXsa2qRqpVvLEYoEkYVK0jCW79cLG/Xzi41jYzWLlxzrnUvt7xtaNXOZyQE+ZY32n3yPSydb4O++GifyM5ixtJV/j0Ycps1JVmereE1Ojcb2OmC4hipVWxrdNyO58JzGkw7puOkcFWlSxjzOU3SeZvMFSkVaHcwr4KdRkHeu5Ng3qlmwLgHI4DYwqUGB0NG5mjEa/HMnSUaeXVNJ0N1UyTqVNkKGynXua+hPqIhI+XEjjmQD3xQl1ILckCCMBdYAceLn/lOtwAZH5w+J4Ux/OsDdkdDm8wRBSdYvAeT/qCOp957dXYEQUmA9SHyUHoOwO4Ud5vnvfvxba/qtXrwUhMS0kUy+JYa/3PXDEhTK9EcIwIwQukqOCCkbC4hIE6uJiHWxNqreNJJc1PaFtuPh+98Gz9hovxb4s0yA9Fn5MGX8afHBsFMDF8SHnjarBU6ssRBV0KiCOS4NBzdFx1ISEIFOcXKqo4iHgIieKIgpN1uaztgGhnMh7DfhucZQPaG6l1OJftD0FEZG56pXDIHTC7RMeC4McQYYGYz1Nrur1F1+2LS6e751n4OyEj7vLyRCRofLyiIJyvYeLyHmXyhIp1vcUJondwLLjuIJ+fH8LVPI8DkGuh2UNoCIafnM/hvp6jxOkrn7TA+qyxT+4IPBCGyn9cRkV+94IHITkfv/TjrH1hwic50fJAkeZTCiMpCSBAHPtHznaec0dNU0dUdYSKjIhjrdaHWbnbyE7lAtxgrfbdAd4Wt+f78drDwxOIETAjnOCELII6IiMFQVrxAm49v5n8fE2BN0JD9dp/HKldtG4MuwEPR/r+UAJyU6KHxLDYh2Hf4cT606zHdDPhK5wSRCE+1hRiVGnSdkqvAIpqBbZyF7nUKjzO56h7ZvMQJMEkMPzC7NeTY1ZDtGoa+80/CPluk4JoMRD0yQEAkUChXwcQGag1hsvcFQa4mL9ovXQ9fwn3Uc9TaiJH1Hyhbg4IjLer9d0RaZbN38SXWXLsLwYzZUFVNpdh8qhStYEIdA4fjyS1VmeEXspAVdZEBflMGKlbtAYKhKTBIRO2OOc557tXm62h4dzTrhyV4B9I/HHiZEgru2KjkQmg7iK5YnBf6rJNjnsJY6kVOE8KafaU1DqaiddlGWiDBMQaqw7YJ5/x63Wi+qyVQEhTJTJGFVShq7dx1vXyO0wlTQ0kasToj/aQROskFQ7kWGhmkgfl2emTHfZU07ZepfXW6nWpDYvSaJqJzKRouEE+DQQROyBO/MNnh12c3D+9VHjglWHjZol32/t5GLx58LdToiq2xOnpU0klU8GPw9fvusDnaR43zNUj3Ljbs3GbttB0vuh34QeJ+Tm0jlw6CuTY6o2bK3RVm8ulqOafEyyadODKzUbT7jGrCxHiPlbImq86v14Vw1zZvkmTFE7/hCSLAjHevA2RsghpZDiutTKlVbArEoZ52P319eZ73zQ6sVIlxaSLWFsLuAkigSGGJVgNLFZIgQT9OLRwkETbfS+75qNliaqCada2LbhoahhD41kIsIwSSQIqQiofl04tDDmQjKKx8v/CwyH0EGOG+NFiVFWfNctk6LMF2shvtsYQQsgD0L7hSz4gjaBjxzpk8XIv+whIwAisidQsMZg/CvVb/v87g6yHbBYAd0RQkEYzRMvpLA/H2HlE/cQKIeiP7ggyDgh0La+bv8/zdOOjpKDSBoj/dHvUwnmIfXF1dg5BKOo6D+JPy/9/9daJrOC/acHj9pmonsPwigxBoYRiHR+CyRGnF98PyyWKtVUP0grLHDaTIffI8Ur/zaUZBE+w+HlHdrfzUfOqIIfUfYBXp8/n8MV6I/ge7b5Y+XzNsMYskQJCQuRy5tRUVfNg5LCEgDGNK+UB9JzeOA8o2JRw5JhDYlHbTpsuiu2KXdtyFNVmpCRRNaIlqbbaD9t5kFxA4HJJVpBxxRudw45LJoPz/X5g+ul4kYSglEjH75dn8xdffUop7w8vUcG70yc+FMntYjrRliFuss1bbfbZG1R0ofKhq/iWIaqJJbBG9khVSQ9OTZbEAzAXl34/t66v26J/A/R+8X9rYT99jcS2Mkyy60f6/uJIkv9b9r/CwiEjYclKILoYqQEQU1x/PpbuUB0D+ZVVK0xK7qfxoPy3KiBgGMViYvDK35etmTno7NFMq18NKQwZQhxVtRGqJTbUAdMDAnLiGFZmCqiFmuYESNiRCbSCiJCbZbEIoVAtm05mGqHftIaWQ1x65aIlVDeRQVFgkzbL7XOykbSwkb0zkxBhZrLnThIE7kQkUy95JOETEfIT7f4dp53FHbXuLWn1z+iHvM7zlB94DmKlAqUfY/y0xiHwkQ6uaX2AaqYignSBU7FfKkVeKhHEFRHP2Dt5vMenUl7jbfjT1GleWs1dHyXMltrXJtfZxulnXSUdrjpHWC4eb4Sm3aCr2pRyjQ74cwsO9sGL2fD0rQraj0o87VVsTaeTq9i1Yblb4t75yuON750M0auXxvDeC3W3rMML4vg2tImpzl5heX1w7b6u30dYS70lmZHviNE625fTd31ydCSGCGCE6Q0Uz1IiNIeqMigSC0hYqnQA8AbJEIVP56VbXsJIk8jdrz8uBoN1VFBQQKqqA86669+ZmZmZmZmZmZl3d3mZmZmZmSSZd3d4hqK1UQNXJKkdloc8jqYi0pdcHSO88kil0wITQi7gJoQIbVtwlx21cckhIRKJ3alkLG4i5cVjsY1LSglBEuRiiL53PXW5DxEeqmoyg0eeed5x4dz5vLouvLuZPM2ksg6m84bzl848jxalVdTWUmGIlyJNtNpsSEK3dxOO3cSsjuSMVkQpZcAShEdT74twD5QP1B5ig8P3Q+bG3x/VPR8/tM2u2OiDK++p/doq7rFp3yIfx/m/XiKhUJ/o82eKQxnu/mu/WzF2PSsei8eCR4LKtTWWrGIo8CCy7QQFQg4QffNKD+ULFLNCEGEY8JR8m4zwhldIpRC4UQY7jr7MBqB495fD/iSljJIxIBBk3ZHcRgcKhEzhrznMQLOmTEH9qGNk0kTOx2dJJCQ0fxVH7P+bCfNE0v3TUP8v7XrfKlRVLk4XCNKf8/pIrVFINHECIiLjq6VqqqCuDbCkjk3PgLozSN0HiUHZGYz8RB96A9O3aOX536cXFvdLGHhrZfM4FD1xxDt6HfG48R3QDPeutK1cZUcHFQoO1z3nuZsw+07APatO0uvJ+DIHTz0/qnykDU+V+c+7uU3SBDFFc5WaMXQAe6yGGmmg1UJlBkllJZatrGSfFYn9KnR0ml+JtDXOGxz7RK2NjGGUlDc6uLra6xjWzExJmSfHjy4eisMfXJFyjoESRIxRYUXOgUQ9t/79vDBnFbzQD50N7yAteqAZdowYFV11ZBOdLiT7j6exvC4EgXI45N6du9W/Qs7EOt32kHq41ybE6xcp4calJWE0Hhd8sKnjgOUkA8/ptt0BncST2+FXD2Eke+JXdKLoIpFSKkGrCdqUKPYZMbjoECBBGRRhAimKQeiSzzblgc/C3kfk9xpP08mfOxBxX+zXG52wuZsiTrOMQO2XD98LQVZXY2EPHSpdQp7yVbGMVilUEOXOghNlylHmBIFUWdiD4SuUTtpoWSvvg0Cgqr8i4yIZD60UI/r/PH7LWIGt+yOy43Nt3kTymmyivSMhamVEtkWVlsW12c3LcGp0kxqZaNkqorJzXS1Sbc3SKnrrxkhAX1hFWiIgenjw06uIJXSHV/huZBiraskWFn87lsjdHKV3k/bHuwsey+5Nd5vkSTTK3T4eidddylvWj1qVEMtkM6H1nvXLgTb0T++dcDgmTQHeTB7vdPCw2Sdvr9/z1MPcOjX6tNbHi8WQhBkjSRqRFTMkkslktKKRru5mazBIguMRoUemET2pB/pihIzEKi5oQSx2CKyIQhpE0HuNPTs2/0ym328W4yPM/9/XE5j0qZ8iQaOxryOLTPL+ntchj+5ORkuS6q5upwe0rAQ+YMH9Xy+XOoshYWyvsFP6o5vopIKw7Px19poUaHyVUHI/J3kX+YS8Gp3iOQ/KjtAgSRU/GY9x4+jHj6tQq9XOZACoVFKcE8xAs9fHodyRNfGHjwO2kPqOYHEPymXQh3e/P4vM9CUHq+X5YiTiFN/khSiHidWl/OQhFWDVMbe/wt5cWCSG20rcrfCzSuoTON5dpJGaPv4ujLdMd73R0tcrWuHhy8lDQNTcmnzm5grSY23xxqYhJY+m6V/Mt79+gPtvj3ko9YitMyLsoxabxdRotGKqEknq+7WPE9GtEujQvSlT1g+oB8esIUFDXaB7RcAeXt0/pgaD+RfUhweL8uU4hvOYP5g1IC8cB+WaikgP/KKtQUD4RCyKqGiEOIRROsD3b4Ayfzr/Qbg2zEkCcKV8fmPUHboAj/XB5+X26MHF2n9T+iNkP9JuysrH5a8WbsyPO7NZmoQZodflxq0ymMYJpg1TrEEX5rBhpXB44gjZf80gbMKk5qq/XVnnhMsqj9pk8WEtItJ+qjekPosmqtLSR98VPUkdIwnxyfWXFSRC98kPhgKJcTmmCdZFxD9v50/B+D8H4Rt5UfcfdXbzLEOwrjuBrviZIUfodOmT0Xpp54lH4HWpziJxEqI8YAWqPIPyGvHfXywfnOz1Pv9GG2BvWmo+GzuvjQedokIbWHkXudCrq1KklGJkXHvQPkz61zv5UNzb6L4GsGxX5Ws0Ttcfid8uzfl+iDl8m3Ga7Sy6DEBgYePPFNsa1p0Qbmk4VI1V8tjRvKjIzOFkzOPm+v5l8D/omO4eppGl8gifJKiFxOQsDYh6R68qlLFK0sCPeWZUkWzqzJMykAqqPylXlxGP9pVCYgkDelFDjA+LBaJAg9gd6maQYd7JuroypZCRj6MXntqvrWNVFZTUNKRNY0yMkAbbGsSRsbZNWm02SU1UJYjbaa+y38bYPp6fvKSf40//lTE3n3tJ1a/HFbiM+qQH8RxIByQPHCrxYPpUSgwv/SKh4RFqStEipWklazGWlRtMshNmCaCZV/pvm78uv3n8q7KlYsU/JJPvUq5J6pjlJ4HD/LrHqUpfgH1xkD5GBItEk5+wXXryDmE1MFkqkqz7/TOeFyLwNIqyz6q2bbdKXuMVoQIGCCaviVBSk1pDfB/v1H2wpDyfQfi+jJ4D+qVVBNm74chQ8yoH0kQ+kg9mO5p6u17jtYhhOtAHQT38z4HPeHAF8Jq7wwVtYVabj0EQccOKGQnuPsm/QjuoqRWw/vft+nwx9tsf6jJ+uUUKv52Y+0Hdz+RYV9gOn8PPcinty58zxisbIVssgzHlKhKqEg+5Fdm+tLeCKaezhjOQN1X925uhpaaRTC8612q9JCSZ4roOFWEU+IgKaGtcHvVsidDEbyRqwRw2fxfGKw9/LUQkkYwJ8RTTfEDsPwexeuf+U1/Cd02d2WPMOkTcYHA8te0PuPcGwjsZHTsoMOHxrgdzjgI/uZijsUNgn1rbsb31KXdz4u03oOSkVX5uPdd6rbIbHR0Ml1UTBJCF+LGq+FMteBW9ISrqHGJI5QyIq6RUVQBCG2KCDaKggSED/MOiUtJ9OsRccJHZZvHQMdKmQHSYt8OzlNyFfXt6Yw05fC4vgeF+prjQI0jjyqecOWteDe1acNHXaEZCLs84cmtc37/o4URveuZJ7QCQFSHyZDzmFX5GSiqwQKUi3WoXKlxYmlBZjfof376XWPlnUcJM+9p+ilKT2/P3cU9Q/BEBdhdPzRt5PfrP3eKAQgwIwYEJJJEgwIgkCC+Pibf5/r/EGfj9n6df+0D16Zxh7XmCdRb1nc2iZCzXodR6hDV7d6PjAk3xJEMmEwp4eaX7LlGgYrC+eyguoMJVEoiKDJLfqUORPm49nR8CR70AKBfKD4OA+OUs7hJygpj0oReO5MAuFPgow6uyHL4SNQ5EUTMWMpKlnGUGsKTKHtIQFRPHvvKWeZr2yKbtevNhcIwNObakkofl8e+fbImOTI+wWRiSrVKtlWJxJG5mn2f9UNliOJoNq1yzmHB0Hv+FKAzI/4P/X7OmTepMzoD51zbeL7aeTF9E19uTq+zT762kjbsCLUOxfEepyhGSeBktARDxPtMeFAZMGPk5d/t6Q9E+p7Yv4MX+pn7WzZVwsKQn1+zOgaPRkXcd67SbUOq6dRQnjE+PNMgdSvcwSJ3e0gHG0qDMkLlgxjGJhcfUy5Dx8dVw7H6PlzvED8OZ+MGCzGIsV1IBCP+KRwMXkbzd1P7bLsoR1aXgmaQyBEBHYSCRQ7KwBB8Jc4CRO7VfjPQeo1Dy40MZCaySlzadwfNWX2w3Hi93iHmBP+NwfqTEDyVwhuI02YY7BwOft6/auGgl5rrksRKAaRE6tVQJCVHhr42Eg714qKWIokpIpH3PNkTewmSpslTBv1tBbBGtUWkE1V61vcuA7uO+vJnvEOz4qQXp+cZF+UxhBDoRiRKnA6d163pCQnQ7OtvUg0b1bGsMbedxgfj05wumRBBbdRMPuBE6bQr/l2DougOjg0TgEMpGCKE3VCTpFvgYey93GG047uEZacFFAqJu+eSyIcZ6Yb32ykH7iYYZt87wUm0WtNhyA5/WSBMvrnv9smlvbDDkOA96I/iXJibQ0SAeCMQxYRP6zIcly+ve/2daZXME3UPt/EeJZ6TnU+OhcJDuT0p3yRhAIRPN3h1ekQX8pCRVEqii0JJECium0l0oou21y1cto2TLbJmRpHKhNh2DJ8b8Fu3HyPzi3ntwSG8Er32d9jgLKrzBIEAimjhLR5IdspormvQ/O4m8IFX0vmkKPgfEjrHqtiENz75tNCNqFIz7Rg1DeXVsvXGTKSG0Do66Cn6IJzEefEdVd+xQMh0OssMTDI+47C3vh76o9BodcTTH1kPJ8KA+AFgIdUuMg+Y6yA9jqEa0VpSkF/vighSZ0DJYCWj4GG4msrrOnL5ocfonbHTstLLC5Vv57lq9sjE8ZpJDrOaBTgN9Vxi6kN0DEGRejSef0jj1nXr21/iCiqw5POF2nd1acsJqQBTeSBHzucCKfGmN53ISQJCBAk3ZcTwtKrQKiOpgSYJ2ErKAzD8YVoFhV6tDDWP6q0PAbSLRpU0W2bVXY3k3Slayqz8RAzBO6hVJYqdWWz9aqosQ7RAFSRIAtnSkwwkKBI3dXREWsVSqszLLZEDEqjLhbMFECG4rQswtRY3chGiMJzuHcpySKKgqjjIrUlqi0Jjao1JJHUFcOhShUjRepFZUNYaLyoiUosFobBGrRqroJd5cSRLELBUYs26zNQFSF61UIO2xDt1ynVjL55GMXY4+w7jbq9vJ8vOw7Chw4OEwc4etGE25IQTu8d3lJGCapKpWECAhCQ0kJD8pksv2u6riU9oYxjVzjq27JeWcoO21YIWRzFvjzhLLiYYNF6WFRuDSIRwaahbchM4pFkOakxR8x0iStiBxN8PgVQSPphh3BF4MCiuFcWCfHkBU2hcTEEJJHlESoMjCJcHWALZMQFW67itvlMmqSKGOUAeodl1AsMEXKzJhbCDYhSOAie8iBMsDukEOEIglPQzW3izP2o9hjfDs52XCgjjj1vw5RxDifkRV7NMGOvRC+6IMkhGSejJQcKo+bvPDHU9cRgSKaF/JU7NoEmecTvQaqWGPAAMCPoMje7RQ1kAxEogm+LrG2BRZSpZikHHplCGWZMjhIpCFEYQhhGhjbCo0lwxNq0M5BY2LBpvpmjsECRzw7QCc4HJjI5EViUaNRtFkxsaaa2ywtQ5ZI0qSYzJPYmIKwJu9N4eyp6hVdOEpK8W12qUlmqQWIrIkgqOwm+lbilCRxr7e6p91HM/93Yn5udyy9EJ7p9lk71iqVn974nfXdZJkxRRYPekmvae9DfE1Hx+31+SG5+tmm/M6WfX88bbH3ss0TfJc1NecTv7UqMD5a+fmev24MEsh64WXzW6JAgKeREhFFJBhHzSop6IfR4aPDULMv5ZHJvQcfJWE8ASReZH8+a5xJ8/qS27Ae885F8RPUEajVSHjZCilPApKZAKiEYC1Lg6F6GTDaVWUJVqlEEbW0mv6al3kNGliUWWLRSELTS0taLRqktFpLUYmcs5E0HoYEzhBFratsO1rBYtqA4c/jPDwPCN8edyOFzmc0YmEqUYs2vaur5fLfX9x1E7vNVlk2Uz1Wh3R3cBgnImvMp5MFPbkPkJYeb4jhc+Q8MI+6IY9tXEqqNoVBH/WR/5uEIXy397xVvjJn+ITgtHg63ZXQkCEJGmG1QlRV1pmllfeRw8/I8cL9Weln047OJgChtk8YY5mMjqclp5wLA5qr+4gxYLPzjQdBIcT0BIdGqGYRfRXyT3k9ePYUX8puLD8WL+qYthu0bLDf1vogSRgdXRQ0TIeZsHKJoB+A+YiSKBE1PxeiJ6JSpGDIUMyc7WVJqUvba+Xm2r7K+bR1XoQfOofVPLzI9Q89ySf1q/2EH3P9GaI9nxn3LKivLBEyUfKJUpbVIxgRgjZ/R60jk7zKdWroBAy98KmFyu9UbO5zY4SnMgxCfkhucmAE/VFlhH5obFFsPNSMS3LjF4KllwccgEwIGiCo0ac7CC4EWNVbJ1VJ+FkTf5sIwsrWIjiw3T7HOk4kKfStFQdYj5VJ+BHR1mEgSVubRS4AhdUpgHy5phD7YlO5HfCEBXehr0h3HCi4KQgOU7DL+SeryD6/ZYs6OU7NNPl6I3tSPy+47KnNkqOjKN3qp9FAYFGBfiDSdGfGELEUqFvMgL/STHeW53QUmDxwfunEiOPXkGRBEwmeHYUnA1t6Th3eKLbxjKkpV60YtPnhvNp1JGHQzg4HxgdQ+wRf+8gwg0YLhEQOBCgsbMV6Mv3SRubhwWTC8Sbfj8x0q2FsiPpBPiskD3UiGCpDFxSKBgOUUh0fj+SiQqfv/H9E/54PmhrE831RqU3jbsQvTWunjFHKvw/i2/LvqUzDB98RrUQ/we+vx4fKUv0wZsfb2siHsYKfFCERbgJk/8aVcQUwIYK9yeX8iTZt8rb3yewrtTNq5qzhdflT6/ua9fG//X8+TJksk2WM02u318RJF9sSiJoHs9ySMGA8KNld28yWIaL+uf2kDsR9JOfL738v26LXWkb+2Mr4a1oiPsP1Dv8b53xE84z/I1idtngv5m9WpjyPl+i0KhvJ8J2AHm5wkPdEwYX64kggyH9g+s94w3JHCH9qNIGmFRBVyiqC1MUlOnZCfjNaixTWEMjsY/P+T9njR/FhHHbSFmxDjH5IGxWfWg1P1xtkONyjMKK1ur9Vt6ab1cdNZ5Rutpqvl7piTZ3N3hFqPEjpZKmzRnV2HT1Z1q7pLHJMcpfMjohtNQ/MJT6flUfdHKz4FMFQ0Ms2zHZ/cGvd7TOn6ef6Fosqmz3f5BIJ9hZZEcckr44e/9gV+fD6JDsNqyfhwK+EkJefHi5fL6ZZIQ7oV5Wwq44JE1USEUB4UIChQrBCOhiH5yiDVDhhgWqO4ZjtF8iIR8XqEfQg0GD0AteeCkI9sk2RkN1DlLiadY6pv4m3SH5fzdVvjDMSz9zR2I+U6zhCbs0Dibo4dCm7ddiLMd0QbpNsUg0F/H0mtuY6hE4HTvPAKWQMBFfNMoOBHmTpw/xVbufHmfHabI05W2rbBaLUlTazZtFaU22NYqRqtSDFSzNsNRYk0mj874XtfSLlhHGDzOUlD8kfrggh0J1NkH8Xi3Pg4MziXbRRZCrJ1uhDvKanYkefSgyQ3UDQe0lZWfZ/hsjHn26mhSy5SQl/c/qTi0miol/9OJISlkiRwmkqW75/e5lYkq0bcVrm3aSvly8zYg3pUmhZDVtui0kSMiaOkdI6XCFXWty2lunS27ED/CuoaP+mTEcLENYiuMHaM4aXdcXDFtEI/NV9NMYNFOkAiJFYQehFitCNPmwLK/uD0953vf8AbJoj6E2sd0/rraCxWiySlWYslCMhlBy/z/Lw5wiQwb/rIXTCoVWAqBKRwAmOiFLCbygIRaYJNAx6xh7piIuQ/H2Z94GQqJn5h/1UfY4xPTNRIMGQZIX2I+dvBySwh14Ks0KCD9YOO1JzzJBjN/WKYsFntIo85qZLgubRMR8WSztHvREh23XiN+6BCRVnivq+ksTI7dXZanXJfOyQkTiRnX1l18ZyCEvDN12MgzgLgPE9npTqqlzc+eo/wymxtir9qtL13UWFI0MpTKNqgYhKIgn1MeWG3hwgwkd3GXCKZRMVMVMV4uneYCNl7zAowQDVFIoTs3awLtkxqMLiQXZIs5BEwrutwm5IS57rZPVeJ+UcGLXA9FgvulWkXSqmOqsgFXGWimhpgmq2QCKIpMZmi+xP32xG+98LNupCdl3rdGSzVRayXWlQGqEVQxGkGIqELqUKkqFBpZYYZRiSWMM5YWGN1oEaoIdlO65bLG8UGmJB2quDEz6v075rKpvSldO5idCxtKmn61f3yo/isomKh8zAfyCAYKgB4Zt3bOdElLc+uU/p56GGOQHF63vC4BfIMp5xp1E/YKV9DlqJ6WaGVb5SWTXl344nkVb550ih8yctOr4ep9CG7SQNhDeq7wqFKBDAkBIJtwcQl31nm8HePnSp6s+Dx4l0W2Sm4MFCAkDIITFKQfI7yO4QqDkLKwtFXeLRoIMEP0DbHsF6UAXLookWhgfnPUPcAZHv+lPLtwdCD2HtQhCGbfcdjgyedxerPvFoJExZFwxZjgmPWLmBPn4ydhI+dC9sEB73ZxvYO3jh+pmw589Xh8KGopDWUQA8qvBu1bI4ddQokd8Tm3Pdh9i41Gzjt9+aQ9UxO5MWSyO2a9py+V4WQaLQwnkF9yC6CRCBil4huCh++Zk+W/euE3TqJw9xwl7VWAZIrsUn5Oj8ufRszRrHnb99MzDJTvW0tYzzpuLdeFdcX9cKfNDn5sIelXeRUI1idUA5yMkZKh43XLsoxvoHV0oLI1BJMzqchwg+XU54Rkbb/odXap18GMREhUwaZ67v4KF4/8nnpmpZQJPQl13W9u8+s2/afinMcq27i/oMPrffPwMPzIJ/MVtbnsozovyQvzwTeGcKerErc0VJCXVDJCSxViZKTCodZIQ2Yg6iP6Igf1sJPUfv1A3i74sN4H0RQgxRkH4hNmQVPx+sE4gtseoN41YhLQR0VasYP5TcJvQIDtAKikhGIh+AQKiv1CL/Mw6B9nB8tz0knr876rxDErw4j5lVP09vyD5jsOjvDfO/wUH7oLuQ8w4IXglZFFTURtpLW887CTNFR83bi/cEI+IiJpKe5Q1naTLUshTGzKmIUmYgskTzvIj0Hjs5DwdtUZTAuAnGLZ1FV20tbJtSaR3Rbup2itjVrETtdUtq7K43TXWaldUyurRKVlvtW2uqS1MQiFp6Q9SwQijIDIob3n8rT9kV64RINx9xSXdMTxKK5Bv6ET4sc3mEmCqKqdV2HQOl2QkDJGnChVF0lmLbPux7hP8s/6USt3J/ZIrkfdNpBoI+49Jk6b2g+nDtRK+cNBA7jvsrzclCdFoisoMZ4/r9tLL2+7QyPdnTbzPf2b81DSHXIwh8fKw44K4U4nmIH7/SK0oaRPT6po9VrC3AVAkHrznBmaPscqb2wSLQdp6pbyHHcHQm3wzUP2thqF2PbnGtba99gIuOztOXKoQKI1N542aKGueH7TXKpuyLriq3WKGzsbk6CUynQkjUlVBro9hKRadSwOTcNNuNnVvdtDaVFuIa6muMNmKxCExHDFQghFLyM5lO6BDNXzSsLrpUIhvZYYCdF3cDRAQhvmk2lJEKombNFxVWFyLFyVfm4f8b7sbsaLxpaV/O9ds4HKy6O6Va1lWLisLNOs85dXejQkNkp5x8A933Elc2RpafHCVu18M8Y133uXXr5h7UiexxuxqtrfktQbqIiUVutyKmjebqaUtlYXqv7K9jh1SOzwzgVJBBm6rVlmh0+RdbD9WcJRoaFt6bvYpUL/USNH136Vq6VRDzvkWi+FemG6uW8Wx4qifNYgs1Ea1kzRu81Hp73rU3Nm8hsgvVH7/jcNNnZsC+PDHprubfi6fj45yuzQeeOJriAzxdXxbwssOl3HuF+L1ycd7A7voNpfB9N1PeuZ1UaR6pqaZw3amjgF536bybY12mCpWUfjIfl6H4OprONPdxWmzraGzCDnSaVxO0dd/Tz53lU83HU0VpJDHS8QkDk5wEYJXBRkww2Upswvj3liRcyBwQIt67bfIm1aCKds3EmkhjihX4Npu/5K15VHd/LwBuyMqLv5yjJ2m75uDydCk6hQYRSR39mlmneh8RdMxQES0ZKL6v3/B3W81szkSWtMMlM9CIG8zIuWrMR0TiQpoEkmdku33xErw02VbUILJxMhCQTyOdLTO5zFpQcp8ryjVqBU7Z2kPnaR39udZCeZW8rWneVKO7reURoi8OULEXqXfZtZy7Y5yiNkVEulXeEz5/B+9+hhOW7Y2DcecIMRxn0EwKR61rXrtVw/Wx9cz83+mzwNQ4nXhPk7Cj1y4fdHh9tEkilIldI8ctJo9vkoePLEzaSVl6G7W2yxWKsQ3jITEIbg4KiyDg7xWg++vqw2jaMjUarGTisKqi2lijlmbFUhGGtUkiMvIFd7KI4Q1yZuRElJq6TYnGhlarOJUpW4smExMC7fK247JMHPi5DQ4dzeluwQXN3bQTmdFAq2f0HUU6GgUnEhAFe2hoYH13RJfdd3NOJOHVYz/D8hH15oz6MuRHUEpIOTeJatlC4iRZza19h688LTKoUHkskZVQIhT66V2i6BxLBjSEJJ3AtW5B02PF+eWgVE1q9I+pYtMf0SmRDeSj79tlWZDiYo4iF2BFqFu8LcbI4cQK9iZbxiypRTVQTMlJgI4g+y8tkkl1TMYsuY7wPSHkfkidNLL8R7e6UI58l8IwigG6OUguAdjB2UhUL5hG267fZXGMJ32enR1mZpdWtrCev62JxnwRk+ST2t1YwHRzOmkS2RWi1TS0P3j8hGN+BV+r5/Ei76/s9HPskhXKufVpgStM/8JchiaGumTSdupCE14vUJxisIjEspZpJBOgdAMUVRFjAgWli+KAQmGcajsHItEj0HYEBb+XkrOGNGF6F7D5RfrgF5MTTeY5gzJZkPikJEiZYcogfvDoxY3uMHJgbmpD3RuJ6YFHwIec7qzTR54UjrWJcDxjWyUBD1NUTiKT39pzQeODnuEwdKmtcq+KOuVAysJIQZGQIIxsEnvCnnlfg9a/fS9b1rrJcrFymVJFJKUULLEhV74SuF9GwW3GOI2tk/VO/MXnR4Cu8wSjS8YHOOlqUkDSUtZbkSaaW1HBDx2hTzJrN3WjuURSkROCM06YHGvR4eeO8cbkAk2c6e4e7SG0UhsKu2ZKtFSXUzJKlQ0IYiJ1FoO6HOy3HRqyElQrlTPTT0hhCSabB4WnagzewVQV2TdW4l7q7uTao0qwECMpgkdWkwjjbcVMZ9wjkruq445fBUfI3xkI+MXKqi+rE7Kl7LHPojOTQE/QiPveFlF8iRIR+6fpH096uT4FkcnM2fw9BvZCN9lozlDNr3Xx3H9QEnbFheKSGxuTVJw5Jh0EOc0UY+5P1Wm5sMSQuzC4wrQGoLk0Idgagc0YyMgPmqnGzP1Sp6oegZ7wnQnEGNvV5YyzO8AX57gXqGo9l7QsI84To0UUnmlkUPf9gQYECw6R129VX+f56MmYTiQtL0hdNFS068l2FxCmD1Tz9nu6Ts8u/OMna6Vkx8wQSr0TxR83OhB3Hxq2+WeM8Dj3T4+BWjLRVhtM5HAX4OU+rx6l0fPjCocwte29GlxgfhQCo9LMnkqgRWHQOjdW9HtAt3msp+wjZwTQZQXtGsP36GImkJIJoCXT6qs44yCJ+Y2b441DhhDHwhvoy4d71ZdDEERJ+5hhwWzDybXR4ujR3pepNh01o5F5gXDgfZ2Flb1SNshrzsIeL1o7yjnLIqOEB3wtc7MXh3a744JvVCHT5FWVul41ok8VsN16bogtfGCpNr6yqLObKgOYHZqq5gHY1HcH0rBcjyKmOqRXWU2EPGrKwyebNdKzRcOAWtsvxRzCUKil5rGJb5ZGiV53m8E+6RWkVOpK84aPAljYpQqRA4IW6VaC1Q68Pm4LXbMDhVOWGyxCE6Sx3O5OliMDqja6xK8EuVwUa6eVrS/fm7sitvNr07ecKbMRhFVKICVFDgRWinpsVCw5LOGY74ENxuVdI2ISQzI4UMZKCBxbCadUZXDqqHt1Zg6V0xlYkIwgYsVRGrdBlIVtDTQuUcqq4is41UuGNNkTEwUQSEzWVExMtUvXe9cTm3FETT4EPgdrm8vMiQnljUlyD24vNvNTC91zhBmDsRmp41xoGitmrurm2VrhoFVVs4mzuDN6MJwzLXOLWUKZx3udo2eu4jw/OV4c3rUb90exDopM57TON6vhCZtGhUKgVJ1gSqIxNxsa0rjA02FZgSEYDiDZjDVT5m2yqnllrZpWFG7y10dNyKw4DEcMbYNO/BKlVc1Km6WYuqbb06UOaiu+Lcwnd6+Gss57j4znebRep33dCpQ1pIRakYhIrskMGgUuBHAW1CEVi3kLaImKLBN7k2ziZczOWDW2rvWcRWaEJT1bSRyxmLN7IWjSVjOeHSbznKUrWVE6vKvPpiDXMMwQNgMQNcEwydO9NWWVbFndnx3pVKtlmHF43M0W1VrZYzTiVtumJdGyaMTJN2jlLRomBpdG6HkGA9Pm+k51o6obdgmzZhIpwOaD0isCSAdXX/99o8OXvPT8XZg0KraGCHNidYaFZhUTod6aHNMFKlviokVsPBQ0S4if6nuo3cKDEhBWQUhASEIQZEQMjuLLHYyadmgZXgna9gOHo5dXMkOFkGKkTnlfGdM00yrn0amu0UOHk3Dx5SFeZDthwi+OXQ8UgK7I9qC7FjQyiOBy4FAVQYTi4Rwmo82THHO3jirsq7YOxuIJwOE3G7aNwYuxcQVMnkN0bWrXPZlDITd9CcSUbuM6k9SAs8yxHoduE80eI4T7teHlcB3biaG/Qd5tQcYBIA68KWJ5zZMx1JT9zlaZt+IWcBYWaSSWmudBloGHshaNSiu2YJI97plgrcwaXYmjUohZMJMC+dxhxYuMzGJlHjq/t+MeFtsh8qpSyqOgyxH6D+L1bz0XahyHfjoQ8AHzKnlJHwUgOGAQl+grukSCwcHIWPDvwWM3yd9iYwVaauZIeOx1neUaHYKFA0P4FkTiyJpak1LEqkRi/fRiGyALuioGmDajNllUJhTB++kwmcTwDCoGloLYo55ZDaNevx68OQzQvLft3dAqJZ46bWYIk00Yqkeu/Ip9I09Ru7k5TTnY/Y/D8pzIcm/I+H2aPe1Ubuks40tVLtRpEsa+DaHlvw4ymISCjVghibO8B/L/1S/6CojUoIlVsb9Go98ZC2b5gcIFVghaVHANui5JMdku7XWQ53bBzuITk4bJ1sfKuEERIweHrghBVdiCUIu0XQEsCXZd3BU07FBCmMYCHC8mYTFA5kDE9ZzOvp56Sean+Hf7ZckhqvpgkDSwuMYkKfxX0owVprTVJahKE8yPJSe6Qn1lR8tjL7P6AbuhxaIPlDlFF74CYgnzzihyo9Ekkkk+3vKMCEhFCQsqufzVEhrTMJX3oxbX7zvcMF0+vJmZDfWW2rbY7qoxiqnzVoehCk+xaSj6TvCvSG3DhieauTJMS4afSclHcVGpE73Gg/Hw5XrjPsPzk6ofi2dq2dlJsU1LGjTe63jX8W/Vvl6+8WjhJW0Q0AN/iUJliCdBIIuRCx/ajtOQ2TH2n7ZnLz9r+CUMhxM6SREJZyFAnGvyn5fuJdLKTRgyIFr5sxZlDElRwEqRVASSBaVO3qVAtFJBmMuA0RDZJvOA5AYh28c+YE3m9Mb0+Ec91sd1FcuHhsbIfWeg4hMBEkGgWnz1Vk6A0gFfiHopyB8wYFxx4ldYhwGLlQHMFJA3ARPpI2h1gd+5LNefprrtSoFBPL0mhVEIa0X66wSw93eKFRE03j2jPu+UVKTuWEJ5Qja+cEdPKBuesr2QA3Q07AkidkV21GM7aacGIZCxalpapzkUwexJBE3pKpyL62djyx/8YQiJIIuPhsRDxIvUxsIZE+yGwG3kOMonQAOQocGdNA2RPPFGBCRY/gySJ72sYmRH+Tp3E++0bRNztDI37R732qEVNkRiJNFGErb75G+6ER/gQKBdT6jKvvkfrqUHz1Y+31UxPjlIkV+Gn9/5oQOmYInAkmx3H/D19qFVIRUV9LGeNfHJB9bJ/AZgCIZoDBxg6kThPSD6B0jQ/SVVkadUkn3FQPu1ws2qa372ASWsByVZIh5LhYG7xnhJwu/C7JT9GIZ/Z/afUZiD5pAmoMHUbWpFSoFXMxxRV/hCdWB7ATrJt7K1J5imiPrOR7h1CLDt7K64HUEUMu871tDaD7AvidR5fyT30fF9JveAPaf8S2lF8JbSJMlGqDu1dEbGjJrWNKle6stustAUMVIC2wuQZ8R0ePhx6v2EEIQ3CG3eOpf6/Va+z4++5o16jyo/RPuDI/SBzGIfsCAEgjqeg9m8jJOO8DvjI8dLWw+1OI8aoqH82JXGRXBxpCcOg/Ebg3JyryyWQANfZH9vIouHCdrDkQdj3UZCK+mQqgk60n6fvo/NgMp06GXfIFHVdpi0KDJo2bGPk+MZ5+GN+z36Q7LCqi2e3V+o0nTrzjT/AsOJTomRzJpEMT04fW/YTq8bFxcLTxUfkv0O87n5zu3kNHeYY/mWqVhYmRgj8d5pusidr4l8SVBw5to4xzR/T5O3f+zVeys0KP55xdUrKGkhqqE860DklEi+I81HrXGMLJIzaXrS57TBS1cbKeohaP+4hi6SJA9n47TgG6q7zwPYHN47/R63cXM3KwtPkW1TNI9fbjKGCVRXwb11fwfaUTWzVKbYWirpq1wzoShHBB7oIRkkgEioSI5iPDifK+/l7NKswNifjwZfdjK1ZwkSZqgKNZ9V1QOA5JW9lwm0hFzSj9YsYrOriPnEfUViGCVXa188lSz1E2PnHaB/yGlQwgnZ65N9QgfdyXhOrIf4TzVXHyuhOI6QcDIezYlRBDQJeOHsMdodiHQiUndXUBvYg0Nnc/ZelmhqW1imRZ1UyNGDLGZCjG5biEvAXtWXLmQDkWEnWOA4AReXgDQfHWjkE+D/V+ijID7oiuXv5o/lgEgctehoHKFAG8wjCIjQwDo7jr5uwo4D957xNiIPadPb2/VZ8eD7bfkhJ5DxPnyYnzeVqQh/8R+a6fohCQYcF8h+gIJoofmT/pEVRkriMJmorBImBAwTme0R1+Y2TDo+P/HkRKPmFY/21PH0yR+6ptgzyXw9tS2Ef3OQH6/9RgyK/KZGguDDuHTkN/hd2X+b0TGxLRL3h9fy/4r//MUFZJlNZp0+aRQKwKFuAf/wQ5X/iQAC/994gYW7ce+zacAN3QAdZ2B2uynAAAAAbRWNAKDNSkJOXbMAAAAAAAAAAAAAAHNYAAAAAAAAbU7dYuUoAUUBJwAAAAAAAAAAAAAA3ONwAAAAAoAAFq7Y63W1qW331FVUJXWq1kSlBUEilFJSikK7qzkSJSSJQhUkiWtSioFQqhM6wA6SCQqQKSikkCVApVBWfAAAAWOiVNg1SSqqQQXAADu4EumbFMBrLZAAAHRd0iiKBVVJKlFUKSAqlKVRSWIaVKkgIoUlKgKNmoqqqClBnAAAs5ECutW2bMlS2wFSSiYAAdw6VdG21m0onszp56Z6ooJREqilKqQD526SKQpSpLEyQgEiKgAShVa1UqiqpRUozMVUpQCQFBFEpPsGVQQKgnfVD5Jr4AAAAAAAAAAAAAAxrAAAAAAAKANqrA24E3buzmm3dACXV1U4AAAAAAAAAAAAAAxAAAAAAAABYnOTdK3wH0RUikVFFCqKNAw207aqVRN4eeegoVERItaUSqJNMBUVQUlXu+AAAAvAeQXbVsmMCthRqlQkwAAdnEpy1JtlBZsK+4EgAB6Pt75EpJSgUSCpCi2yilRC2a+we8dpuHqpVVKFKUAgQb3cu2pJ7ZKq5aveL18AoBvfURJdtWxbQqt267MpUhLAAH3cRUp6YSUvnT0YG+ONYASAG2wNpqmvTq4AzFPWmgokBlJCJLXDoAAbSidWywpmttA1TI4ZgUTO3S0bYmYC7O5efAPDyAPUom01lrbQUFCvdqcRIfXAnMapSrFm1qxECNltaYVIzA5yg00AgEoqU9J6TCG0mj1Bo9EInggpSplPNVGmEaAADQ0DU8RoUpJMUyg0AAABoEnqlIhGk0Eo1BkAAAAIkgQBJqSGoNT1MnpAMm1MCooQBCkSmo9TIYQyDBMf7bV/xX/OkYgRKYRN/tav+3drxQjJAVrUeVtauugpLawYxt1dyFk0koKQVCgYiwFVV/0FFgCNCxSEkwkSYkTACxM1H/uFkM3KzEzSaLCNAEzEwgFtkUzCRFJMQCEgMVpAYBIglv8AFaM4QojEm6IN8Gwi0S0ks1N2hk3aY3uFYKcER1YpRFD9z+U/lZRBD/D+n+j/b/f+v/i1z/1/bdBAEF/qDwIKH0ID+asW/b9Ob8/9r/0cOP4x/ZP9m9tGqOqBpWi9O7f0CIiAIBpf6bd3XEGS0x3d3wKao6xuWepfu45yGOsq2cN2JduaameOwori6p56vFk1hlVua3N0mzxn0IunqIxDZ3E3mHOLxNjrVzrV2JinEKOUOvF2+9jaxtThiWO2wpa50ZD1LcGMRnF83M73he5uVzzVPmm1zc61tTp6O+rVS0U8jfALUy+k3iHsTzsWc51hiW3C45HcYmpfjtGbmiFdWaXCBAAimljmyqkNpuyNlRAmAsRMZkaeMZclcur0yrnT9ZYenie6eZxMg53vUVSbMmCy3uBt5ee5d2bFZrWHbZFQ2r5BNYWkAugAqbvrBHRCiJZLHljXzf5969WrUqlst5kWnikq3Omq1zXMbVbxrXNb6WvnNjqDeBaZizLQJeAlocxKnbmMkhJCmQmYkQpTBCaDEpkmBpASgkiJKyUKbJGSAo2jRpIsyikxRYIlIwmKTSUmjIkaQqKgwVo0UWISiikMUGExkENIkgZMySSiIabNhKbGkTMtiiZosJFGh+/4qvq+UyTddIuy63XbJt1ut1Ntd35W883XL36/e/a/QmLJmWWS50pIPOSCtDGN7F4okrbMXzglp2ZAAQDmlsVb7rUq2VbTKoxA1rBBBCjSCCG53o96m3pq1r55z4ms0hUAS8VUAXhIqohVgBDza5L8Z/xCcftuzZ9y4TJIhkmf0e1VS1bbFgmKAwYLEAyUsM0kSMlIhIANjDTM2BEyQRZmiI1CRjZDY2SqEokpQImpiSCSaNSCgRsgmWMZfv8W1a+b3vXx2q77/E/a+3999rnu+973vREREe973ve973o3oaGhoaEjTx48ePz8/Pr8/Pz8/Pz8iHxJ++V751rPy+Xjl52JrXIrmN531vdrUXzw5cwgAG9c8gdAE9fKEV7rbJ3DqW626vNAIp4EAVOxLEtEhYhYkQ/FCTFEMEqNqTBKlEpMFIRxh/CU1Vd+1QcgDpGF20iACR8aEDm4mEIU/ihtq5SWkryzytiSXv+YxaJR5qSTDJLgTwlJMUnOE/bLdq9fue62v4aCNJo2CxooLUVJtJYtkt/wa5aNoo0bBoxQVRtFagtkkMVeS97dbbt5K2LYtG2/4NykjU99uatg2ixXr3dbwbaLaLHPTxRUbawUaLGre1VzRYrevrta8UaK2+Fyi1H9LvjrXI1gjUY1FLurlFY0at8Uq5ti1io2Kj5W1XN5jXxWdrxrFRpNjVUGsao9rmKNaE1RqCi2Le1uajWsVi0bmuW1iqioshvSbXuV28Xtq5WNjYo2zztcxii2itcuWxsVJqqSjRG3trpsVGKybFsb+k1qvXxeelUbYJNURUVJFrfC25VFqNFW9TXDbEVoowVG0aioNrsV+vd3lb1NY2pKqNtFQVk0Vi2NRbGotjVG0mz26xosaja5xXxrt61/Tf03lXtkxY0VRsRrG1EY3w3MUURUTVZWDRGiva3SoNoxtiCr8O7rdNorM3tbcxkpmixo1Hi1uUblzbxW5RWisUVizt2uYtBRqKxtFRaZRRiNRSrvTeZs8WkrXpVwjUZAi0bRaNY07tbmoqS2xZ525tFjFQUm2NbG11X1D2DR8gF4JcQSBiL8n5zS/gP3i30hGqf0lnqh4SyUp/EhcUYSQGPB7cBvABuZBxXf37c153b551337782r34GQQv5YbAPoosB8gMcFlRAg7Tb5xaOb9fMAJkNwHkcYfC6DhHQFA+0naKTn7iBNcmff2U87iHDnv7skgNu8vwFyFdeG4ilA2IH5Er7VECQpbc1RUaiNoiE1Fk2IxGosFCM25beqzwWNfMySt869W1vK3pkkxqijCCNEoKhSYm9mqWlpVQVG2iojWJKYbbZMSQ/mu3IxRbJYsWxteq2pdNtf42ubeVTXNjWNFVFkrGxvprmjajGtirFf03LY9VTXyrbxXNa4bQYryrUrvO1c2LRY29rcKKtJbbnTUUa5q5aLRUVFUyKg2Kxir1Wc3VRScmBlZLckP2IrqayhbIFqW1URRUZKqIqNitBtHwuVir3ZVyoqxWjUWvn5rq8lg2ItFXttciqLUbRi1Mi+FzFbFX892jaNYtjG2i0bFEEzW+aAdhUBolCoF4IdvHWM3NvPvHWDn8/LfYefaaigKo7MFTYEsCKVBUGypkSkpKCiptZA/fnTdoHSRFDQNoBQrAGDv7wWBVOLnOFn2NiScEqUkKhSUQ94dsoQ0nPUykbyyQR+JZBO+a870J2qoF0YKqFAvAM38qoJzlEA4qZSCWk8pOaA5QVNb/Rknk45/dBDA+58ZIWyR8lkS2R+vyj2KRiG0wERsrG/FAd5oQpiDIDedzjqhrYpA7ndUFkgMiibntEim3hf306586nQiVw9eiAhiM4xhQMGuvcavgKBblubO0xOfLc5xeO2u8WFHgRB8Lg0TI79JgmhPhKTBKSUnxKTRJD/1IUlE7JgiNXvkbEyHx0ndwQzrawPAOtbc0397r5wX7yBo2Dy3XL5y8c1fPwems8zJ7xbO+kQ0XQ1GTEaBIZERrwj1Hz9eZUFZMNN1uwiIB7QOwMUWIUEWAiLHAiq07px+fYkpVabQ+Px3v4AHC/a8Ods0N+QoccWMgTYGicy3y/W/8YqqF+fubiTaS0667S8ttVv9PlbVrYfQREQCeenQKt+8Ak5PQOY++zU1s76H2Ey2DjHNbF131Nuuueel73sfgOwOoKPMEORg7HUl5tJJzXmuuwmLGfBBBy9+8c30NC1vq+bq2+/q62/TCBDaab/O6FDLGAhDKBGlayFNqxGkKSiRCUpIiJS0BTZIUswihlBndyTKRMpIxSRMmKMIoMUTFf2uIoJoSBpEQGSQ0ZmmNJBmGgGZDEjRjeddgEAhfTiSMaSokYCSiYkApYUhmXnclJDIqIkFEq7u00RkY0yZiIIgQ0YkyokiYZhJivXcSQTJgkiMZmmA0xBBkmRmZqZEQIyhIIBF41xSGoyklMTEJKTEia7q5oSfx2rqJlCRKGyeuuTLTSDZGSShEklBJQlGEJkSUlMxlRs1MBMaJIIJkiTTJgMKbIiFEw2PTdhJQQiwyAiIkYSaEjDMlJQGSaTNFF4u2RTSgYyaWrHjqLJEmRMYCmGMhpYzEzISMwIaKQkWSNc3ZE2STIMSEBQpKDJEaMykgo87oAmaSATKRGWRQu7tViaQkaZRIxlCjBCFy7JMkSiDIkMYpIhCSRgNCYlMWCY2MZCGIpIzJMb23d/dvLyZJUqEICMQIiZKUBmhiSRJISkhLM99uiRqsxICxKJiBGTIGkiKAw1zjBpookluXWQmmHtcyQSSyBiSmJBSYgJjMkZpTSDSFCRIICIoRSDGZCEwYIwRM0yIKTRB+9d76t3gu+fNeYBsZJEGKIiJESKUKSQyaiYQmiAMBQiMFGkkZsj466KT47oBIkglJkSYMkSQhGCWrCCEZG8dSWrAMkpNCFDPO3YSTMgREi7t0NJiwKSWAKVChYpgRklmKLEyfruGENJRqEWEwymCCULIRlCIpIZYojLMgkSEkGMCmGSaQs9OMYwKBiykRJBE1rMMSEiJGku67DcuGkkGwjIIjMmbLJlDYgYkmhmaSJUIpSg0SYNM0GSAxk38/Pl4331xTMBGRBCmCiRGIBpQMCBSKaNAo0JoxmYlmMIkZokykyjCZERNRkBEqRFMhD57t8/13maNMZIwmQokqEjTFBSDAZTEkyUZZRr05ohNiSZlJMlrYwgD57kUgIIwmgEY8dfU5ERIYAYEafK5kaCCMpGpAiYkowSXndhklKK1mTlyhIs9dzIzUShEZLDIyWGhECed2k2rE0pTIikjEEt53GDEaEaZQoaKMzI0kEohpI5cgCMfuq+O8ZkWMolGIntcZ765IkiE0RQ5bkSYIASMQmUG87kIJF3cYZru3ITAhc6iUQwSUwopBGWGGvG3DCBINJkhiTMJlmMMxCIQMKUwlMCIxITKMMVbCQwUtzkTJCNSUygNM1VVX1v755egn1t4c/z9+DMw669uNvxD+MRDPfe2tt+/PPfPfv9fun3PsI+kEVQkVYgEUTHvXnXntZ671jk98OnvmgMx629FaIfOfuX2c7RtUt4dptszjo1nVjp8+d/N+iRCSzTKJLMsYkTJKIQzIGjTNAGSQKKgiUlK/tdogJi1/bpAMpJILEYSMTFXnV1FmRJMk0SPO4wZjQhKCYzMJpkyMKQBTRJJEBAZYVBU21ZEl8zjRlhGUJYKRZpRAoiZZYni5CCkYIBhGUEudhM0JRgNIk3dc0KGUIRGLMBmZmOdJKf7u6NjQiYCZIYGMmkpXvtyUmzMZpBIZZEMmSJMNeurgBkxIwl46LM1rT8/XnmCCSIUQyUmRTRJgUlgRTGgxIMpEHtzBhSUUMiDZgTCSFGh3V2jGkkkUYAwMizIYNjOcQDYoFEswBKRZISGppURApSIDMwN3dIQjFIYmMBpk0Mq2m/V2t0QQpPhxpAYGRkDJMyGzATNIPXcyedxQMzEyZTEJJDYaJIiUwmZhibzrdMKE0kwn+7uiQwzIEbJKKSnuXFCJEITIsho9dyIEIyUSMUxpYkRKEiGRskL67XImgzIlIV3crer77d/Xf15+36vV800oRAiAKYImZX26SUMwhRhIiEyYJPyuGVEN53ABghijGxMk0mMgkNMkvG6wjF51dlGWZpIwhMmaGKQkxjKICixTAgCQA0UiMBgSKbFLCQyMMf6cSS/vrmNGSUYMxCjCYQxCSmhEgEJSb9uv26SUKKExU0k+O6arLAoBSRMZKGBCGZEIGuXQmJRhoBGiSGNIYKSPxd2GAokYZDBKFKUMzCFJRIRpITIEiAlF527E0SS1ZI1rNCEkSaUM92wERfzYxzRmGdU+T7F/Pfnt37E8g/qE1PSIiahmBRMSSSUsgMWAkVT0eApToRAc5UDmCu0ET2CHxYjyiSeJ3tpjRPvCtMiJtomERhLJIh2TzOScwjrBKUmuQEPC4LgACijJXRnA3Mt2wJt5k54ZF0dZPa4EVmLhDfqtc1x0jfk484529ydq8+chrqtWtW79pAQmMo2IIjJIQJIEgQknVd4921MN98b5P2OWjW+1UEWunL/AN3aBO6HeBwBkt7W7TiDsveACGAbtHOhH1jYTRQlCxW59WwBodlecKXHcRGnDyE4J5fM42V1QCKqN4L7cbD7BOX6M1ShHRBB4zwODER2MyZkTdAtb2vARGvNeqpZbbLjGCYrzG7Xf7nnxWc/b2Sk0RHpJKRBSfk/omSpSSfomhoGgaBcDBWwAtgcA0A1VKpDBKQnpJKTBMhgmSZJgCkt4TomTIUknwnabyeJoieh7u4H4DoHQvI5BsCFgewfQbCeE9PYlJySk+E0T+bE+k3Jgmibk9JsJiJolJoTMymyZJhDBE953J6homCfCVOiepgmf25OTYmybJURSfWCek2JhPCZJkmSHB9JoyTBknJNEqUlQ8MEwZJwYJknJPxPSfE+E3T4TlOUZJ6TcTJNkyTwlTRPWCeh6UwTJSYKhuTYnBMk8JRNEpOiVP2/ZMk5JUomDBOUqdJXAn1PhME2Jon4QmEwm5NmGgYO47ND2DQPADwNwfIDkGA6J4TapsTJOSa0mSYm6Um5NIeE+E3JlNJ6aTs+mDBNGiUTsnRPU2JoTknRMkwTxOU2Q6T0ORyMGh2BsDgGoTIO4Qdd4BgOyYJlNyYLcYxj4TROiaKmxKTknhsTYlE0n4nJOidk+E5JyncKnadJk+k/E6JgnSdzaYTlMCeiYJ0aPSaJsSnJMBiaJ4TBME4NCX3Cdnabk6Jom5kwfRPhME0humyeJ4T4TYnxKnBKJyT4TAlSZJwnRPCYJsh4T7agk73OfOvLTzx+P3+Z/Q561Pj9Xd+ZH5V/cHlp7k+A/fzm24IjRbsGw3B+iAbcS4IjyT6IeCUlJSSkpE4vLavbtW1c78b7tHvZPvy67dWQzzxu1MLVpbbFzYs0zVZImEGUyWBMkizJJJQUNMyH+9w2rJiEwJhQJghJiAYIozMkQrnRQJKYSiEkQlERSIWEimTGYERijJQISEJYjGLSZEwiZpIQaJKKShYhopDMF99wv9d2SGQiEQMgkgmQsIJpJlRERhJCtZmBE0kGAmgIETFMlKYbTSMUSYZCarEyYUJYhGMCYkGNIRk0Ewc7nFGKkiKmZkEhCKRCRFJmYYDBIMJJYaURpH1WcyaFCMkKJqGmBiRZmUmhJkZJsxEyAsJEGmykJhNligmZJTMoKZESSBmZGiVM0YM3tXJRmc4ozMKWYKMyJgiubpQSoZsmBMIjIzALAkxjTTIQf7v57xJlCIiiDNEyJJUhgmgooZGKZiCIZIpBCERIjBESUWUMxZhkklGSWkiZhGUSTJERiNJQgQbCIz05CZBEgkWCZEiKMSFkimJCIZDHx1yMaESYSxTxd/H1+vXqIYAsSwIRMUoihmpkZJIomhJJnx24yIl8ddkwJYYVMMZMjBDCFAwSSku7XTKNMTTElMCUEJCDurpgsG0aE9TiikgmSeOiZARpJkiECQIGUAiD13SmiksmUkmRvt3v895iRDe3URIYKKZiDIpGUE0MMaEEmZSu7oGUkKYorWTEULuuoKMQL47phoSd3ERSKFNAlhBpBoSRRGUgwoyBSIkMRRhhYFKGMDCigSg0hA021gRJTGJkyQkM/LmQYBjFMiiNMMgo2SZkpiGJmSeOLISQBMMMkyMQoVy7IZYaSJojKMzJCUSxMQzEaUlMJEon7rOBlIoQh77l67oxBMgF4ug0kTMmZIYEhExoGEiEyUaGIiAiKWMRonqt9eX4vr818XrEyCaSNMpIQTTSSxk1WTAhIIwgMb66uZmJSrZJIsSZpESUQBMgRKaEoNIuc+l0kEkk664I2BEMaCEBIGMoQBRKEzJBvHGjQCSUSJGJIFJRRDHv328ivToyhNElmZSaRhDQmmTEMjGppMkUAJJJGyIyhMV7cvO6gCURMQxoSgJMc5KJRQGMMjMIUAgZgrxbiYNEExSFCSBoQjKUE5wyIRARQEBMpJklEKMwNLGC/F8eeSSFaxpLKIokq2QymmQyUJjCR663MYCQiMWUaNlImYBJZISREEaWEsURNmQlBEomRiWRSUAMzSRhYMFCJEihAgsmMkntboh/t3SiNIhggGMkYRKUKYCEkX1fW+/6/F+b+L4rxPPPP3wvszQIaPwt9BCIcH3r5ufegruj64vv0dQ2E0OVQt+rOavOOczrfO+bJMtpqhW0EQBOPJyOe4ImNDkTnnIXOudnMYFABAOgIAQEoAQwTBDBL1uTyic0mohROcBDiJQkTJChKQolEoShMsbK2tqJ5NiapDVJjOv23nvvWd9+ynd57olSpvy+a7z1rcFAax3GnuxZhEKRokTGZDIRDBCZi/vtyAkYgYMUGIWhozEMGIjRJSkoZKTCYYaSDNEhoSGYYhi5wopQxEEJMkmZGCEEYowZbbJIGlMpoQmJLE7rgxALFAUGYoyRSG/irXpq3nm/C6F77cYwhJJlFK/x0UI0GzJIyEylSRnORQlETGMRBMiDSExgQIpERiophimkU0RIEoSFmWGfHdBlIBGiMyjGGSJJBSDIAUgxGGJApedyEiMCKNEtPjtXJH79+byMxkSZhBMkhDEyURDIxomSExhhIwYRMIhKRsEowQymxhRTRIIiIoJMJimyzfHbpIMRKKJT47rNDFIzMkJCkyQkCRIUsU00GKRmILMZKQyQWtgmNIA14uHxbuk2JDRRpEF53QRpERi2smJSRSNBoZGFMyhmzMIkQAyKa9OSH8duoyDINkxjIkYXrukRZd12wj0uWShkMbIhEhY2UTRgmKEMTIjKCGSSlGGiEGIWookSRjJ7VSGN97iuwKwGBFK9gk2DCJRSlIUUiQASW1lJpksWITTEBmkJYBJikmZFEzQERkgSmikWaAQhMNIpQmkxbq38+bz67ciyEUkaZYqLJQxM0peq3VzJRMLzumIUmlISjAlgjMtareVv3WVuqy23l2fpwQMhAyWUxAhkgJFvt2BlgEpB8LsxkMJqsJY2ZjGSIlDxyZMgGJ510eLVuBApMUjCBMiSClKSlMkEpI0gxjSAMGUjJQmKERSxEklLBQmCYYaFkJIxIqQg+11+Pq3r8fe/v9evn1/f8fPnzn5+e+e0ACiGqpiACRFAdwYEkpNvckaqGiY7d60gomuspHnqgfTihDLAQdA9p6bnHWOAb06GEEnexP3HXHaDkm23GO+k8/dH7zYTsM+5A1Ggs5Z76Bul3mtbixQTku9QgITvu1gDfUd77tlXkQxQqIC0IIQORuMEomnhNjir2rlwmg4kSRN6DD93+593RPkJl3r46m9tjYnZpwX8myaC5+VPCYJknidlQQ3xcI+4ZlqkJoYSSJFEMZSfUba2zjP423JBOyQT5EQnIIhhURHJJvHXPM5L7eXTzXh5fQK1z2o7ZeI5NiEiJ09sCMAu9VLdFhAgATKb8BdjnPeTRdDMJJJ77V9u0vGgeQbA0DQOBPCk2SoZPiUnCbIwJ4TjmO7jBvoRkRWU9ClVQURpsd5ntIFIzWmeBkgJjniI0WLt1x7snOfhudk+EpNb5cE+mg831t5i9cYsTfyxa4OwOwPAhoHsZfZTdKlOSbpglJubE8JuTz8TokBiI5QewaBoHFe646MX3yZgbTAg787g4TgGw5BoHXZ011fOOK0cWrs9ryxz992pPO/3fWPn3DnfdN0O0N+jekyHPsOO06+AZdWbRAgQJXglAgWqoRfhTHOczjJLWubNEsWGA37IPckEN49bVnqQ1V9dRsZrURO2FPSfndlU3kC2+V3M3LavXSs1k1Tz5df8K7+Vl1unQ5DdNsV8GMdQ5e5UR2Zm/YLhH2bQI1406blEfd9VYJswoOZmrUVAbyph+zrN8YMsQTsPW+XPUtoztbtXmbubYYlShgG4dNEMyW1DHmBCaKkW7ld5dj9ucmc9LY2UobmobeXVZmRB4rL3TzdDOyXtbVd9sre0KkF4Ae6vn9Ifnx+O3k73CiKg2wUFVxehFCiGVCWKzleYQsuvhknc8GXd3eK/TuqMReFV4KUhG9iXDPTt91AOoZ7TVuR48ieZJuSkMdVLCqBl0b4WM8Rw8AZaHYxFXptQinDzq727vS9SruLe9vmsBXY9rEb6GpIYnh1IMUrqi9g3XczgXMdjrh2W5mKuSzlWBFNU74bsIpSLbldsQMI7oJDbBojdmDZxmXW0KnUqdrdmUeWhLgXUjfMMXDfYKygcPZWc60Y/AD3dHclajjTGkWM3sU0jsj04BxvbC47tH2D1VXm+AFunGxpMJnEHtu5Z7dkV9WUt5mdt7bxJODUGnpuqlhi+e93BlKOVh1VdRxQma80MNLeUqTDZbyb3yyz2tEIAlB/46hsNkvKkXCq8rkzg6t7hAAkU+lYzszWRK768G6KzXtwSor77JKO3Y0rRN/jZtZSmzVYmB4vs3QRD8lerNYhj09sW4pYIbIsvGndWolzVoLICL1zBFvXNe1LtI2a3cWYIM4kXogUraWKAi1gWS04peu69VexRHFVtNxWLlZdEPuSj3JLmnL0HqmYBzOKszrNmVVTj9rWcVrRm5w0i38lgLrQSzmT0vpjLQ59vXyYq3WG6vcwVvBiEHdtwVNk3u5HvNCnqdVevA7BQoYDDieUJrx766jrLl4xamA8LV6/dhBqGxO383dYnTG1Saz77X46rGiDnMyZ1FyzZ15joDKZAi2hLv5jMzDLWBg3VJmSS2dZRziQ8rbe2OFEvaTZ7D1rNSxWC+xWajtmlqDMkS3c+zeGrXHjqdVyS+YyfG67lUSixaiFIxRPKHpTEG3zvk5mhmXt6NFL2IrH69yDe6i7g1mDXHdOwQZw61oi8w0Fe08zFk8hauVOqB7bFLDK6gkvBQ33t1UMbPMXqoXBLOtAZHW94tAmJl2s4LhjHr667hHm07wzbRx3BYQgu9mpY90Klxw9WjW3jl6ah5bsTlbHdmyMzb2hkqZHHx2tBal1zbp7e1QwyUyWgwlbIp9ksjLcIQ3J0FPGIJRl5e2+zViY+yq1KHkE+V6fsrDWBbrd/FJ73k7cLEGO6jO5zGhXFYTYk3ppoZQzpnXl8KYdY8m0/r68V41DgsK5VdQwWn1ORipKhuZbnyFNYcEoXWzW33XjvuKmK1zOMuOg8CsNTqyXby1MkfclQcM3JuLKkfSil282AzjtzqsrSZToUSecIx05MTbVG8CY8rBj+ufdOmmtKZSfgo8Rgv6/obrdGkVYG5W43TUGVm3zJxvEqW6DijOL24HcGBUDeuhZ6wtLhrhulPEOwwxgp1IZ2CXKdXhM+0fWJ2P4GAgvjMurYBjX8/xbnCP86/0VDPtOUTMiQ/AyplaNzoBeS8hR3b3IqBpN5S47lwMeHNBTjprFEE4IxlG81wRgI4Tj5ZcUN7tqz1PeSzBOIVZUjrTOuDN5gx9gsfqu1LbeBI7v2sS/nQpsGZh6VgOjjQyruTzEGRm3RiG8PFNVuLQDqw5BVoejFBgZg228d2KTlJ8pRure5kG5Fr19tlLhaCPleOObljbE8ZeHX48L6lW0AxbFdxHtkajlBQMRung8ohc2cPCaufCzIDvNZ5KUa7UbpsSZ1K8schLnjIF0U0uXoPGUWp3Xu9b04LvQd7uFt9phUzoY3lZrMswk1WDlWlsM29J2k4tw0r43YzJ5Lb1GjpDTa1GbwWvM6azzNp0sepPAFV0KhuPO7alhDVwc2jQu+WNpCgmE4gqbCw4Q5tvRR5ShgMvOmCcGdSFpF2nlWLm5u1eXs7MmF5K5oE5q1UGf62wtJ7fvvrM+e9w9gvSSek2SuVLHCTMxdndg5c3KWc5ZreWHNs1oQ5IWoKqpjEvLh41A4HtSHqmdac/FV2ZY2nIHu9uqA/LCtQsSnOhlSjOxywttQatJkNkWb6tgyR3crlW3dBlyxpNTYfJisTvrcHblu1Y8B7FxDOEC1phCy5Wc+qxhRYh42Z2+0xvZrcbl0lJV4esbuzeXASICtvot2WmTe7UlUqq5V0IKE2tYwLfUzy4k6UDzZFhaa24/GZlMmSuvJb8srbU5CK92Vgkx0BI/CZQw2FNBrGiEKUM3ayxv+bKgjO+vl31vBts7ik36JTeV5Nso6oqv28Xby9mIxPUWrmu9OKZgpNiYdlObNtKARYaW5qZYruWiWfVmYmO3HlZ2JRWUnbmdt9e2novZYlF9YMg3JdUqGZ0WuUNcayYOlIBV3G6kCzAq3p/O2tIMq8MfT7ds60e4B6MKosgFkgwYqm35MZ4430LMzGq4Q1uWYVbBoa3LEBGATf7KYcNMUcbrv9J1LcFn6SSDOCCFQHYAoXBWJx5lnaN7Wo4rduA722GW6ZVFSYmzMXVOzOgAR1jTs3uJpyzUPDm0KVvqw2bwYNDUyiOkwQAHHdmq6PfDZPSszdvkXCWDR13JfDlrkMLVOGRmv667wXiw1RR36Q6MDD9rxl2y5ti/RahlWTJo1YhVhS92nQZxPd3FERU99nZgvldmYa3qajeHWc1VgcNWt65gSTvWOw7xBFQ5WENTVeYczudVt7W1iy70RT9c9rrvOHQPA3fpZkiJ+1ZMpNMVK0mdmoVWkSJl3ts1DrW1tjWNPpnMQG3qqypzBCyqGuuHdjWWH3VpBuMJq1taynmzdtOrhxT10+u8MEeVd92SgzV7vHd15rAauTDc55aVyT3GrXr4zqOAkZ4vSzDlOI2WoseSFXpqx07u2dBFXud6SsilUgC3qoKad3RuTiIgHWY83bKJ2r6WsobHtHNerp3gB5YhIf5+6WajKbKdcfjc4e5r7aFazT4DSgmb/KU+05vDBYWegNYa91NMoTDV3AfrMLuzvcTWRPc1Qb3XXNBB6E5H4Aey0uQsbd51QPc6oBpHZD2tjqVtvjUOXm6xKwsu+ZDJoo6dzZbdbp5tVoq8c0qkONWOymYhqaFC4EyeN5V7WbHgji59kLwjsbJtLo4WnCcSxrT6tR07vSvVVeTk4gOVhyEvrZv0DBkJ7Ke+s1rvOu5yQdY61sha5yyNVrO7fd15M67Lt3o6h3GZZu/PIpppcbvI2uPc0XOkXXnQa7q8yZ1iRRTND9Tldg2Wwsm9tpS+vduHEJuxYhcl3FQ7eowZUrZub44Q4boHOztlXNcKzZTwLjpsCZMbGXe5DoeVRRYjjWQjsodaNm08521La1keA9typS5btat8APZdBwVZNoOT2GvWp1Q5k4dc0tEjpMy7eYFkXbWRaajd4Hz5PLHcqljqGjEc3QXl1IwdHK8NwzebHYrqZJ1yViz5/UuW/Qwnud9CFd207rPkql0FTjO0aQYhfBPIKwXy2b13N2mXmTt3swzLJ3JWHi3XUs3q11iB1OHdtsb3Dkuu84dp19AkXx246F+LBKDfndgGpZGsoZTYUvGCeyiQadIiWxcjDF2e6+zjW4tdOklp88g6ZZamc9axWCYGRLsXuGzn5SH0Ls9gI7gMihtfVQ6DNy6dEM+SFHvy9zYM3vpNx2spGzkM2JW9IvB8nLw71PVLVkyQNE+GCUbqxRmJVO4kc+3nQSlKI327fGmMrmRgo7md2EqdM7wA9eirbsI1+zCGZzob9ZkS7OtUsi87EJmMEt3uXFT36yC4RIIOmbF3kKm5e9V5ByzMQo9bvTqrRclx5bzHkvsqN9iRj3e2NY1l3gEykEjeVFPVVeIY3TRiu83bb2un59oFbmjSGKbPzRqBA/fDCtwVCwteu8yg5FG47igIWo0yaoKy8LvBR29+p6WMTPPTEyKNjlpXLNFspCAs2OfU2udKcJyOCz9b+H1fc9++rb3c+XC2vGSHGMqtZhji3fdq72mgFwgZX0qQco7GFVlsv6+OZdSwSAdEomnzVWqvF+R48bYGKrCVk1Q8B4tb3fdOWRzlMRgT4WDSa3mnkI0LpdX07LX9Xv5/ftHWtb38TtP8l5+ZQx7Q0rMykaq98pRPnBWQhLS5WBwa8xYMd5+nwYd1ePkUYuK0TOdygNmR1rwlkZWYu7FWkZrKlahmXYApLMzqb2PTeEGtwKr9V9K7h2HnUqxzYNPp4AeQ8B5UOTDm8i+RwMdKJZUVFD9iLNZrps9ic2PJU5GH6WMy3rOoLnBL3NsnnaNZgzjhKxxKjYPCrLizHnLreT7L+yafpJXHsn2XM4iCRXHb4ZRVmBDLyRiUQdvJr3Lm7N7Kt1yxJkvOrMdj2jlD1hyzmddFO+gdKZSlNN26lcHb7kAj1gM1iIrSA6gF4n3TswvocxybzvX0vleOVqre5cUskzC5MNb4a03Wb4EH2bT0U1Wex3rpX5dNDUQRDfrWfpOfVu1MH3AlF/WCcrpxuEYjs9dtc43eC+FR83TmiJzWV1C3vcOmw+OrixrWMuYbq5q5YXUqrvdmYsZVIt4r142jdvJebDqUV1fZrwGFBwgoig0HSsitlCpcQQ4Y0x1EMxMpx4etGY3e9nWLO2+E6d2TpVVzF7lmXejGZJ6Zj6udTbslx5SXM5zFTpyKQSXFXA63fB0xK1Nhi3wSl4N3e1y+67uG1vAS10w90DpjU7511gSsGJ2M2jmJMdzWVoI6ocXNCbiuguY10Jeb23Oe87M1y8LrRdA5M66mQ8M7wdbfbL1uRjE9ZmKpN3eo6LO1UHVZWTZeDlYCNncEyhhonLqhnugre2oF7m3WYCYwd6Dt9t0O683XQm/k+nfIaUDZqq+HBxHvAD32VeBrAgxqST2b1+h5BWevLsZuYGXfM3cVaqWOK5Tj4nTUniWaip7d8VczL02ktUXTOYtovFwlA2s7eFRrclWzcvIdXavtK+oE3GJKxh2Eui1nv6ECABGQJ4BgE/blGavZzuovjvyavYu7LVM1iZsi7MY2fsG2Pua36m+2E8NxALgwFsEFFPTYCb6Alin7AQDAXB6YkcMB4wgATbVWHfdXRPbVlShQduue8FLFRjD3c6G5IeMm1L7A5RvhXB7VPE3bNTjvtLrB2M5vVphZdBg6tWduc0VWPDumYkmmAeCUd9S3MhnAuTn2DnWIfwNdZlWuAvjHSCuiTf23crRauP4dII7dF3mqnXRzhMrViR3HONOroaNZm5wsMXvfa5VcQh3mqymcGpqkiEXKlc3TWE5FdKEXul/ZBKGVtztxRk51PdNvL0+qq8YtYXbRSvYo74UbKoAmHGymPNVsd1qxNzb0lmBxQQU7s1DG665YM7jRimxw12IB0cyYZ+HzahXb9O+q7wjQ/ky1VwdWcI1NaeJ4DcrY99i66bzB3Omn28KboG37aIXHS66z5h2Admw71GS3Ua29klZpGbl5Om0YdyPVB152sLtO2rMB72rX13VxJG5yVe5714kiOX4JvxqzOML+PZJPgaZWoZqy9nDdcNXmcIZ2cz2Pc2rXkzTzKyPEsYdGaQ1B1sXou/AcBdvxMorM2nKmb2mSpxzzpJ8sIMqIHtlhXKvMiOPQB4V0xPMtkSUyHcuRgmuybjt7aZhqAvszRtM+6xQlTbKo6ZI7x3FuuaLWgtdCNSyXCfuRqpWr5198HPlr2uk2gdm1xHWYN6jzknXodWUtFw6+62nEi4yxXc3OoEnEEALuP7vkaBfCx9OFffTHq7uVrNG9TjHUHBlrYdXgenF5vc0EgA09Ok315hfYnWipUWQP43b5Z8el8kyAkL+zN320zoO8rvc7093QY4QXaEnMmDVWYa4Ot4xPOG26d9jFLIJs4S/ADxEyUiuo9zF89UmLgcIoGuILHtGu1AHRuMLTo2rYzWbwN9oO6ufXucsXbce+QmNJirkdK0lUemZYqksUTSHUXxgOt+AHuoa+vrWVxbUDXg3NRDUAZiSqFWqEzHlaDIMVx3TYoAdIDtqjlJqncJDTZwutZC1Pe05MoZYtowFvoVAubCHNlvXYrEadXZw8tKQrbVRizE62SlwiMmoufbg7oFkJHp9LuXXfUMdQy48BpOk9+UvsavaOVqt3V67jpVOE0SZgLxCyLlLq6bne7l27mxbCZYlC68APQYumW5d0UUtS0nlandgiRIRduAdLBrlZ1ymtNhO91Vjic8teUEKVTBC6ht1x8WsSqoxtVrMrXCRZsdb3nq2dA05sK81KXW4hwhkd+Eso5ocvSjGka9S3R2UUFVwGBur46Dc0mVhtkCGH4HM02/rFyd7H9tUVirDhZuCbPhpndxsut1zmlLc315sy53DfQ93c8N91Zpd6tbhe7pha8dy3N2Bp3erNQIyKKX3ObWSs55ODVWcpMzGVH16DMyQbh2l09KvmsoUPVQ9y3dfOdzN3KvLqcKgmznKsUOoE91b+sj+3Kdtiq4yTeFGWFmOGb8rIizVmi1tqiHiuMU+26l76eF0+xKQ0r3qnFCNrVbpg3w0ApQim7ldygyxYai6Xr/C6olKcHz5bSnFXFSPmvUAQYv3/j9D8YQPjb+W5Q0tfPFCMaf1PEC6rNaoSfk64EJtOWq2svFul6coaFentyM7rV283oeew6O/plapipJ652yke3AZv11jO72AVMy13W9cDTNE9M7ZMzug4WFBpyMXCXYOg0uUe+63uWpKCWdd7Rkoc6DddssltMPKGaSxTFUYGD0bu9xGlchV3C1d5izes0jJqfFKjLljO4lk1rT5ZM/n5V9QQJ+xc+2o77RLbqQVAXcNqCt+Mu2anLsFCSi9GwJx0PzHfyk89sWX9c6s07AX9MvoUSKUCcKUPtuG1eXRCdxJUximF3uVGYeEWPoONZGMISq8dXASLS5ei6whONWMrFITxrqW19pqEwffN/H4vAKf1FgnNtLSnM+3UT+B65WnTuXHyv7FBTH5uwlclNx5AlKPfXWMRX9rs7ajQ9lkCB2k7l7vDbe1O3O87i0SrspBcNWY+Lqq9XD1VrJmQ0hk57yIqlxcLXW2i1K2g7J8rjwBU7nJ5556qrzt2sfaWNdUeb+tzD8PmmNjm2roVKs1jydtQT7JbekVV88RQU4nc0TRE81YspPX6S0uQ7N1a9fudrmCJMMnMF0LJxk68ve4rqAZ5eOcdwvpVhowLCekmzR21UuIJMX2was4P2DZrvloQc2rp9Vcbutc0zNpqpuDp1ng+Egy7TXJ+VCxZkYmHizzzZQSiHUG2KKF5iLx05E85JOjep2GnrPPXJzwWdaQIv7IvlqPUqX331KxoIlWa0vRpmG/lzjoAw1rs/d8/hKT7jVjk/jn3XWrOuOcwDQp+qq9yIptMgGMItikFBTZrKlEcMmj1n1VXuzD0ndWMCC5D9mfX9L1fZ8fu6s4CQacKROrbx8whnVWKbagybnIWCTmNGjGHl06OhA85lVe81V3WAoaIGLmltscr6QEWVsIAxAQVmvyHnQlq0dMNgrq3trdopgrzj7igb3H35oIEFcUDe2277tV+trWt8Tk0IDSEmaGGSEzKaJoU0akJIyMYQEUZosspKJjJMhSDRBkZEMZhAiIU1IKZpIKZDH2uGJgQmEWJCIUKYUybIUygiQxCERRRMTCYkClv1W7d91uu0DEEUxIKJoMMIiWZTIZiyZjVYJYEmjIYmWCGSTGQwBEDKREMFjQDGRowpv77q/zuJEYBKE2GlChkTWsEkzKRhAYEpiioWCYYoJDDBmMYTS91u6Z9fut3jEoRKTCyUmZRommTREYmL4cQ0KCQiygJEhmCwREhCKY0CImQgImHddiIgMpJZCyEZMZGJsRiYmkSiIxkxqJRomSAJKEIlKJjJmJEMl7revPMQEQIE0Ot4R9RgrOKYQ8w7UtB2Z3ZjUU9NhYLD/fG7yntbQkq9CVHMzcq92tZMbiy7yPXUI0UVA2ICjdpmrNCKTHozAX+teg0MWYU+K4ORU7p10xJ3vC3y1Wq0rl1RazQ2FeN9XEXjHDNubWLGMKtjJ2aKOUtkY1ncrL0tEKYw7EXs9VV6XdaTpKculFqMeAk7czXZu9p4EJtRrRMzVgpO9Uu9yHWsezcVXlHFoVS0WG8mijJu3a8APWg7vSJVPLTIcdwOYLY3Do2/bYp5kqFVKw3cWK6k/facUzXK6g4JiMmMk0uYgMwXSZw3INW1iFIVkpFQlHYr03MIyOUWyBHRrKtVtsuBxCtNQm8zIpNmB1NAutMuYnWvRSophU47Fkj4wK8R8tjmrrlXk8bU65ry5As2FrYBE2URBkoEScDNYjJETmGENDPAy4EkaYbtANJBIBKZH7Lm04VlXAaF5mWDkDCczoqnlH1PEAAA2+7YS7DN0JVENvJVqYZRck3ZjqXTMMwzZc27oqrbZrLmBYGcJjxS7YJJCss2pdBvKkwyJWZgyW6qYtBsaAaChg1VF4Yd9W0qFXwK8wrR4QMPR3ewiiawaKWIrA90ZcGVV63XuTnQVXdHEK3niiNlk+yI09gY3a1gsOj5lUgbP7dXU8RmvA0+7VcdxiqGuPUvaDIRLCFJzwvLVog5ktZYqSRko2TfgB7PF+dWEXFHZZ/V26OthS+q6ZDnGp1Zb3KuMNDcguVlKOUwG/ZG7AlLHiAvMcivHNu71w02asPbpDPSJL81VQYKIV8LsPUxaGjsheOXEcnjoaL3XE62sO0NNpWjsNXYVwYI48iOy9YqbCKdaSotmK/e94QbV1kRFDZdxh4dBMONop6NPjdRS8VsDSBdF69cb22KFNxsZ6rFF+Sq4ZSox0/W4DSVLTMW1e5WLXAXWltVeYl4DiPe6YCcjtEDH6L3jKNVI9cHmzLHXrdXZNNeUNTxNeSjskVG8FTBencq5mPKBwQY1URmvXJ0vpe5LFbjy8rZkhm7NCIcCqXCrtDMgNnstU5RcxS72sdUtLGVu3sbeagZZLlUMpsk5aDhk2U4LOJxYTYyNCLfbd07kKZVYgwTCJatpzZl4YCVuhkaKyWHjm7lOq3cF63QqLJH7fTMxaXBb0HC1rIQkR8zW0DlVt5MVhQ0ZKDJqirwo3ZxkZuZob154AetaSi9yhguZg2WJtJ0CtpQMuxbjpddwnueZJNi7Jq2syrt6NzbbyCr3DYFE4FJUp66VOKodeQ6VC9rXk1pZQVMjpaOZVZMl8eKd1pUZpJunG9EWAuKHMFc7wdb15dSJiazTzIVnm+SukFjMu72GKedK807AYb2JYMeWNdCN2KyoUEaFxGrEFbEf4/oLKZkyWRKUKJCQmmjJiTGDIwywRkmjFAJggzaJMZE0sWiGSUwSjEErGTJMNNMxGpNjGbGCKDMW/bijCkRkAUCTEzMoIEUhj9duy1YiaQEETJGhL8/528WAhLDSMZgCkhRJQjTI0hKZRZKQjTGFAMxJFTIBIUUaIE0hJQhCSUQwbIxIgII3ruMmiFINNJSFIxKhmIRQSAyMzAZmKNmSQYzSYiQkgFCQQSASN5zlYXeNxavNvwviywXDWrFSI8A3A8N3eCwQznhtnrDqVL0K8eKZc9jzoHRRFWXbrwA8ZMHHTKKupMVrZLgOX68SE048YQNqHa6dSVW+wNBUFn36V2TCvnx/OqxBhpwWDX2h5Vv86bu7vNpNC9kop097OxQ1HG9l0HdggyqGTdoQMsypSNg1vRziXUyBVbMoKc855nY9uwspjGVnbM2fi+a+BQlCCq+P1fTDSOHdV6J8d6sOdt4MTzphhJiNPLy8hj6O2xIetaSM6ppQ3Bbt3e3QibCL5lWtxPhQqHMs3lgibZWFFuBQbh6ZVHPGijYk2FAiKKSbICfE+JJIPjWbq+IsE93PCHpG5MPH5bDmZFeaQtGjD9uhglcfqrtUPkD6m/usMUPllrxs4jKbbErEVqS7L6gBQLad6aUjkqbeeqq832ZfiJB1IPbVTk5xU2b+PT669kCI0iNMlJk0gfVBagtjkyC+sW6ErVedmRbuDrjjVDSGgio+45uWvR4nVAgazRGvuzEsaIJO2bl9w3fCtvXloAgggg+PgQSSD4mZmkAASkZB9dcpiCSxhOXteWnZ1mn03xZEW8S+6xrE6ZKCl2DiWoOwpitIdXbWVVBQYMhu7ILx9k917RRJKrku9vPjJrg0n5Wz76vubNZ8hlmcfsygPQMB5izEDuxKnpkZUkDhgC0iVddIGqlsOkRjNIHK1eQGt43NI40matVpFCk+D3KzkXoUHmqHI20aJq9jdPluKg8zsGHfXAFm2rSeKsbdy3s27NUtLYJV08dFE4WHfbk3KJjxT2U6ydNGJTEPGE2FIfPjWwjNtd4QK9/D54zChSMWSJKyUAbxzobgN7OTcxU1UXcXh4vy70aNQJ34a0GdOHNbBy5rF+Hh6yHkFtu97tRddoG1lSuobp2B4sLtYa1CyR0zKCkCmvm5jNaOvUKZWpUsIksSl25Ru0qAFIykFCJmvL4474569/j0+Pj6fFostzhTW9GVsAd5tUCfIEGO+VngtoqwhZ16mu1Z7IKBwJ4MzMsDw8gYVgX6eV9fPeERJKZCZMYZIMgA0/S6GxkVIUjKN3W6IoBENCTRJkKC0iWIbIiyREYEUKmSUBSk/jrtDBoVAkGEGQjAIMxDKBkUQmhYUQ1MRozZMk87hkWGjUwWDFDZZDGJImE7rspohGk/jrlCBmQRMl3XIwEQFKYYyIYIQkTCQgWIYQUWSJtbM16dkyIWExGedwLIkpIzQhiwYxGUswUISAk0iIaMiZAxKZDJCYlKSEoIwSihiIIpmkhSiZkgCZBNJECDYwhoKLMIpmyTJGGCQNETESZIEBKEFCgIIIu/s5GtLbCidyGGC7Bmbiyav9+fX1fBRBIymRIrKZFmDAhl+3MYJmTJTSYkZJEmgg0YoA9gJU6e8R+lOQo38JCMBrqgKQ4P7MSu1W9Yb/a/3QUoPEqP19u62T0Kvnu2irwcbGJSeGxaVRw4MmXsrBxy1K4OjuQ2c4wGDJgVagZjl7/G8hsVCh990sxGyrJUjVl9blP7C3uBROJbqlgtb2qZgJalKSab7OzbneAHt5wv0aBNpF9dME0ruQSoAuhiulSGYu7c7Nry483Vxcb63UOjI95aHFsavbuLNSXDK69xqDuzYsMyxTkY550j3qNcaLu8fCHJxyVtCXS9gNW6LPvAeT6ke9T29rsBHboTkfEI22AtOki2g+i0xN9mneMFdikM9T3q3W25VZ4Ae5eNTonblc61g4Luj2bDNFYYnWOneRqjERvVFQBTlGR35G3fLBxk1MGre8+zZqM4ZuZ1TcqdsS63nOatXlcEikHu1sFCyNO+V48p9qgCrjHrQBMq5l3IBlUMuVWWxLcMUcI2sZXoikJupWWCj0SfYKaeVxrhTEmdVhVGtWs5di3vOziKpgMbGmhRxO2lM3gaUsXU05cV1oNL3UqJcwx7lTpm8fR2rB3MlsU1puW+3uOVm6Ho4VPlnZfJbGzYljRMmGckdpwn7N4+4uli27LLkyDNYGvN3XfD1soLKFahJc7ue9mw22xwfdmqhQGPA4UsF+Ue3HTOu645fDqpXsdaOzwA8SBWrjXWKvtC1ejuWwBL0MI5CJG8qMPdW1w2p1F+AHkaxZkPgB7apQMk2OlVO8rztVo7JbjqU7AiRtjZphvJfVvi4nj3MxelT2dxfmMgfkRb4GyMj2KS7JlKO2lVvFeZHU4aWocKdiPLt3SwJceq9mEHXtlE29gMwFkvMy9hVsfLms2dBB9VD76BYjSvURUxbN7sEDvSVmXB2zBxW4eyRgysJV1eaZgmZuLKlYLKm2Ny3fbbMheZXYLHXY67S4sDUxpbkp8KbzBU2b7Dye9srJW8LPPLn32hhSx1G0To+p0mg5RlS1gRVl1qD22DByFjUfpdxZgMlFkgAUfTLShlgoJFiuT0XBT+PlTS5IHbE7Fcm5VWhjiPRmp1RE3cpO6WN1FHSEi1RQrHy7uA2xGshpw1ciOWnphOFbuquEsSwsCxzcYWeGgLsytuzRzD3dudeHNE7AvAD10KIzaEsDBbCWDpmtegs6X3qqvGWLFpEZBG5ZupBHcTli+1ay6wZuP0oxVL2nmVMtKssaCruCrF0JsEndxb0nxCXZNdPiKWixQI0czTnaGy0syTn5+lxlAppMqYs2QnN52/ZEDz3ZATIF00JVkt04FSrVNxRQvpNJtHu6s2mBvV1Z0tJRxq7xXLRh9lFUExjDgHk7VKJCw9jBSgPjZIndjGSr6VvGnJ6qr1h9mWjEGNVveiVmG6JfujSSG7Mx2kbfDbjlvdoEF2c59eErh44uu7639IKQc6ZwKD+IME07m6GaGUtqsWafs8APaKN5GelUZsN5HGCVkxzMk6hbYujm4VwumsqdQip3Uk293Dwv6Wp8bxj5/GVkDa27VOlC7MAm2LnzzKIpcGL0JSk85JXlsFZMGKu1v691R/IFMc9+I/bNNnSJ+GxyVqtqHFn5tBK1sVa2voshgx7HeSm89KoKv4zb6fZDKt9c+tr5Ktvc28WCZSFxnlN1lMpO6EIaaRBNWMo4gZLQ2ZgzFiw471jbxct5iks1gdgKRXCmoSLtXkOEouSREyYZYdqAUAKkEynFT3IKFEdAe2/NVpxIXe1zrsyJ9THTTFmXhYEtQbcpYc6wZOTpNWnWOpRoUrB3OEfmqMgzrAuhi0MUTvd3WNXPcj0rcrl4AeV4CT3bt1qnTW47t1OMy1glyQVsSyIbfUpYXCsWunLNcwZ0zBd52h2asTnHrySlQhtXlutmZi56MkpZik2FCTuKyLUcvTWDRAd6t3p3ZXCXydRCo9QL5gl3stuD9EM4ooerYV9VyHtxoFUrwkTcS+RtqbSDWRq/AWk951dZkNLKk4njB1Rpjd6QPObRBGl1lqVFvsFPHWmjZi4bIpgVEY3DqrmGN06M2phqGKAymONWTD5TEOet3YWiuPHdQYzMGstgjUgc0HgbEze2cpdd3CxCAVryALAr0+tD49pnDBTs9G6F6xiDxPFURxqSc8trKz7nZFFvCMtAcJWqk7i6dlimVcLF6gxHK00g9IcqtuOfy1Z+CbPTa4JXLx+ik7bxV9H5BVubkp2Cc/XcMp5c98XSKCW/EuxLFOQ2WXt5dX9Gc4ZpB0Hut7nDrWS3o11zeHriCCvekp9y2aV6qr2ZoB3d0VSw2MBFDcLw6YMIsh852nUdEOq4aGOlplBalt2K1utzKkm0pvP9gphMNO/hR003So4ctzlWSpEYa24mxs8I59mVgdPKvVtNREWHJy05bmxYlgR5yVeMVZ3lonrFjkFwVWHViLpQo1MHS9ORg3nq6ZHNfLROD2XgDNLnnZS1y+Xt3VCK1naBJdiWuWCimWXwq9x9j8/X3+5vufzfvechADvNPs767DWnzTQYjlONhqrAYBAB5sjg5MDF41mY9mFdwwlpsaULvIcfp0KdsLOSCHWSPq+lfv1xizsrWefNs9OqKF5H1G30lXj4rqIkxuheTrkdLtm0J17GSVUe7mCpRPPsVG+j3H2jitYwHSeNxTirsEO3oxbowrHXPIWZtEc07x81j1ne1M9uJ073FUrcx8nERbeia8ps7tEQEY3QmLZvcxtd2LUuI7FZWgLNlcLWVMxZfJwurrUKza5yoNyuomRiGYjgX062BLrAflgldM98E62MCVlbe1rLqhW7kKvMvdE27Q7srE9uFCbk6sIq295FbjAF5m2m2XlGssnN3utfLSMRWQ9ffCey/iNkUCDw/IWNnPUNVSeNWU6HbeXU2+Mmk4lgxISinJuvsM230aE53KUS3DwMaF4qN1sd1c1Qd4Aezpx0h9mrV1c3k3IMo1fXjuBSZsdIa0NNF0AIWWcyKskyosGpUHWzM2MWZiA2xsbGnA0JprfVVetAmXLGW7cs2bPJTMbNOHF3Ekse8BuEzasXzlLslUF4Aet4FaNjae12DrrRJqu/n9OpZ9Qzj98Bl+rUBMyPC88ktD3cmS7pdjUlkpt7YYyduMbhO0nvsm5fLtcKvAxG3XJAmujXU7xHgtx7Ok0U2+q8DK5wda0ULCWtP2zSbGLQ3O3HtdNraTHJQwwOXQqwYJWLQcDnaq9VeiUJnFTO9e+GOYHcvVcNqpjWbMEqZQpFnB6F5doTGb5IQiamL6j2i6zZgGueFmA0FKqjyewdmIF0TgzsFsmsflzmrLxUwygcaLwiUUJnYDJCCk4LEFpeLGinrGBYacUOd06ASzMG3tLLpSnZrJ1PIy8qXlh/Xiv61sueslmR30y2KlN+qh76OmpdL4I51ydSyxqhsw8oK1XjeEwOxCQgkcqQmjr8b0dgeasl00kNW8/cYIHlV1hJ9papdqoakbKwZtjVEKwabHYSkVXaJV4U0geJIcWeAHsvt1zeD7AqXXr0KYWNZSui21L7E3dqwWpnysSY6rd15R+2ekwUkmNaa1QacN1is/NdQ7SKtlQY7ybEalLFeOBhA2hWkKis7YIRu3mRx1HQWrg4pL71mYuOFY7Q0KOkxTNPA2ixS2adoCacXBqjUsYzkoaRN2qohb4AeVPC/CtNo0wjpFXkuWrpFsYjQmDFbjGdnF6DvW+N5vN67tgLqAd8GA5WqtnOs7uE3EMGxnOcuM7twJQlgGuJVHb6pdmuQsxAhBvseBmDOvUI0okS1yeRKbOyuuZhHPKuhbSbaRHZKpSqWUdwZSueMQ1URJudLdQTbXmAQlkVzBRmt3OXV1XWCXhyUuvxWCs3R25S3rOoiLty7u8PW2YNhweA85q7RsXgB7DdB5ojWS3DLOZcLkux26GDw7WLnYcVRTjRSwzO0KLWJdF7RsnYZTpBi0yC+wMu+qssPJh5krMGbbIFC3rBFIdTiHbXgB7qx2gwequGUsMsQXlRR6Ig1tA9DiVi7ADvyI1KcuvJ3grUvMx9iAR0UL2aicFOiyewZtFQjcwdoynoizb7RC+1+qZryxo6IjZoWA8+28vMdt5LQVtjVi7Zc3npzCoktjvYv3HPtbE40oxrMVILxMwphm5FM7bFULVZXC0eaFKFCJ3mZdHaU0dp6FXryDjKmOCa8Gzi6xCJafch4aPu2eYv49spQ/XaUD2S8g+4G5wIZNeI3HM6y9uzavpacXkVcTAkmqEyyHLVBFOUlj5dOqYqW6AsuDoGgVdzDwN50Tm6Ut8APSuZwVOSxi72sozNZQCQQOdJU7eOnmnOb6rUeXr1jsthjaB4N0+N0JWnT2UMBC4brFSsHKnD3Qbva+F3GlK2nTNNEMsuoOqTafGt6wqNIR8cgyI8Ro2hmm1lK+xEmirO1sbE28gga7tGk8L2cMSTWazTITpbvLj0Opnnc6akTZ50EtnSdqJVXkw5zouHLrJxFE1r56qPDJ1xMzB2TQvIbNGWgS8YvdpKbfZLIRusogihmFiVnGDZHnaQ3b5usGvO7pzmSH1hvakbrfRRbuIrJZmPEe2hmOMK8yuzaJwUks0JPtdjVl0pzI7ube8IZ/PL6xldWrVTgGVh+iR9VV4jIa+jM4xMSxcyXd7R/OIRJrETDeOr522SCYQJDl6EnXUQPlM2sHx2lj2ZlMYsmZkTIR2xYvDjDABvAneLUaEFT58oVEE+saXlDFWSzIqe6qutfb4Ae2TIPjtfaaQ3q7qc+qyyCzHvQmUxu6N29F3mDsj0STtF4oJDLxa6FyS9q5XyKd84OZ6cfa/nWOXLsIGoIqN4yRxcm9Md8eORqjmXL57qnPuesvu15XWfS7clpsXt1DE4cytO1NL25WyC2XWYLYyvtvbzJupuIRyvnJ8gNJSnDdnJbinLel6nT888GWpM17XDb09fW070yN9WGzFNs0gwr62QibPPMv3Z1YGO2lWHqfB5XJCzfaAe1zgZz0JoNrHZYxRaKhWtqFujFZDvVK6tImVndE/htfz7nN71xGJXZlWYjXEe6V0x+IF/N1tl688BFVQTF+cAxkiEgySgZkQlFkxjFJBExiAwmwYhRMEIondzQEUkpJDRFFayAmhJGRAjRMr+25kylFJCBRSMiJkEJJki0UJkMUxBMSJoxS0ZIoUWRE0pNEmTfNbra5P383niSSGZJBImBEllJkNlBKIQkzCwxkhESYlCZXtyaBMK/tcSU0ERlChMRBAJpkE0EKGKaJBoiQgNhRGUjElKWYJCYZDTMzCNCmJmU2ZIUjTSDNkSSCRJokiAokBHoUMSe0PdqDsLUjUPM1VOzSstLYiKc3UNNZdP+rJZvEw2Bgcujii7FrooQJvwpw72mY+mIJi9yJu5W+HBhl87dO03Myh0iMqZFQ2eNYZWEmOzG2NsPurdSzFlihBkmzcoQMymMVx0dbQfi1kFXdqRmGsd3tKx0vOAQXtVSTDMuFjFl5cs7R1NXbYrXQt1M7WJqxrCKD02MeS3+fPqiG6xQP0+6g3WpaflhkgFHrriXuI64fAD23tYFrNp5xrMrvdU3cMuk4GS3YsoaxtmrhU6hOyhqChlkrhg7qS55aQ3KktJWYCQsc1hTMDOHTeiBTKw+vlBwVcsmo6OcR4mYoayrQ/u7vtD+bo6wVqiUFE7RVLsl63MrRtfVUY1EmWOVOBjsddMNbCOO9Y6+YXubneII2s5nD7ONAznJKOFkk7pe4VRETA3tNi9h3erq7HusG76ZeHc5wLxJB8SCD4+JJJgChhgZTAUpEx4lbESOkqEca6xr0h4Jl3uPOOk+HHihUV66qeHhTBUQSna6uIZVw0uKuHX5RjXdjrl2pq2/FJWXtORMSSoKrKD0jTvSScNYru1XwkzhTNg2cfXQdSms1e/dJmRI0Ug0Q0DECoLSFMHSdti5rMrZocWeQJnS7RAug34KkKAsEeAHqiy66d2KJ83LrXfZcRqccTFUB4yw/VVecN9Lhlidj9T8APAEEWlGaEkTJRvvtwFleIBFpOHBdDvsGfPZltJO0zN+SaE1PfXXWczZZ6hXThbxcfAD0sShrwrIEOZ4PE7TmDsGGzGr5bdKZnaycOchmKkcQyOXTWjFIGaRZTWbV3Ses1xQpnIlu6GbjfF1UQbQzUkaovT6lAuOZDCob5KjgirumqJTXxmm23dEJRKtTCxDBtbmnNdDIK1QpvzuyBqoySuvENI33OwZfVUW3PEOU0GupXHmDDWTswJWeBx90IeuiMlsq+2Gty9O9oD55GH8TezfNpaLEtJaX3xvNR3hvc97KzDOJV7jmuxDYZNk1hQF5ucmqORZCfeJJBCM0kaZYozAMRgnhHjSq4RnYZl6yxmq2qcU9l4Tg9WVap1RIQQIiSx+8/A+10qwKPO6oMB3amXzvLPWCVC8NFJEA6CF1Q9qzN8b2YnVHMS0y9FbKggZBIJBB8CfEkEkEgE+8T4glrOdWLHPTUm3KksLPAr4uzN2sskgkfd5vbbBBNpyB6rY+bmr1aL8nUskXXOgSTxg4wxSOhXZT3dd44Rx6sBpgeWi0MGs5UmyIvKy8plwFDrGZe1apm83JK2K2S/Y4ZZwozbM694vU7xIdWgypC8a6AVWg88PjokFUup0ITz0OXzxAs7eKIrmvWcmF2LgG7miY9XXb26WjEBm70ehRVpvRhE7ipSuhZZAx6O5izSK7SIcdRNTjiOMP1WWsyyhrdwk012x5iVQZNuM+AHtTTxUq1RYD0HaB2y7bj5d4F7qIoKuj3xCk1WsuA8tRuJOysUt7ToYGKkq0VtSsaxTplZS4Yr4YMiEmPtVSPDXB69thwywTm2MutrWLUmkSIjZimQVE7sF0NmjK7PWLd5TBqKtidqlQYdjYu3PEiOVxdaxM5y+rEg6gdGHltKhTfW+3t7kS0wtxb1GlTXdwndsKmvSLNZHMovaugRs6u5DsShg0hUbeSXLLCt7EAQCQSSSQQcJZkaRIvyumSGSCSUNiQYRJkRMFIJEwiXdxGaGiMammmiX7nGiSFkYNMYjSaabEkhkm0hmghSkpiwlEIaZMBKYsCWUr6rOSRsopEyF/nT7reS1ecCkpQJABg2LEbJjENBMhJBCNDFEhGI0kVEppkjDIBZCSEEiEqTMopMkjSUzKRdbukGDGUzKKDIRkaEhnUrhMzBQoQQy/lcQGkSMimhJJ5tX9/jy1vTWNQAOJfUACdmOP2svQicScB2V1EmGq7M4uiNobrV7yyFhvnSpFt1HdC23HdEzm4D3DEAbPXkAS0d0hOIGXcCKkY4qA4d2tzqUpGbmzuJrWcAvdeBdtByQmt582ooNZp6z2UKpJZlN5oyYLBtqa3v7r4UV2vn1yP6xxuffwqdYp3ZxoKq+9QkEFrMU0a8nUzUoqJqVO78v7K4aKK++DbdyfInvsx45ourl4HLRQrBeZS3Fk1AdbqhG6oTNgZDAKF7dXL58ILaXMW8r0XLbN3ulm5pAdVp9gSFHsOtILcwRtib192Gxtpimb1PX6/fnKeIIIJIJIJBA0MJSTCIKGIwwnxB8QQCNQeA7yeuL6xd/Fdwh2VzjFg+bVVglzrwloIEIyUx3Xhoa6nLFjFCi+M0w7tHMOKgwbYTCph+l1gvwA9M1ubagXtUpVlo7s0m294t3mY613JWe+vV4aQTEIgg0NFRAJJmGGqloIyPWKNWxaW2bWIPiniEpesUVet3CQMyCvG43L5UwKIKid2KuAy0tNvWIQQSN29huFQPbQvjuUyRmRENEgkUjCMEoiGAI/Pn59/n3fAgvrff5+Pr4wj7gaP4shtBfChekDfizYZ+7UZ9k3u+EaUms5YvNp5ZHVuc6g66mjWJWHpFOpoHmdqHCVXUg9j2z1GVLfSG6dzOV0+xJ4+YD6BgnrivZFUvYmjMpSHjb4jbW9UubiNH272kQEWiKrUM28DVMbhczwnPXsnpKvkuPcOrTWvsrNW76qr3Y62cE4g+L51wfc7Wy6fbwo3SUpjqGKVl43WZFYvcuoTxFkhsZlOOpgM2nnGmElz45QTEGTdciyVavqfV3BfbjXsvGyhWL4+SNyZSWCvNUGPnZD2dmkgkgkEhCBAjCEIxhGM231nfJWdr6zJfGL3+H1BYpso13MAa5jQ0mRKrABo8GPPwGxO969uyKGlcDjMHTzrC6w09piZKjG3YsQiJnaFZ4AeuqV9rl3glh5sOrul7q3O1DdOcsVYVHDK3GKMR8SQQQfEIzAQIhQyhGV9e/q+stBEoyzDIhfJ4dbJ8Ic6peyg9YhFEEGzCO5vwA9RW7Agxx7t73YLyZeKqwuahTiVihAanmKIkXcsLATqia4/5AQAUAiZldzf3qz+83vvfMAEsBERwPHudc9skxWosxve/Gudi5RvoQDtijWgaWAuds9V13oBOZ1lAA1EVHWksd7tAgQNvYyjxsbggUIBwRy2GoOHXpV3eytxMQJtvp3jmM4QAJjFZPDj3Y5oeVg5jqMUVTZdQSkhBtKsC5zQquuJu5NVkoPAxGcvpp55k9wr1krMGDeart1gVjsK5BdFCmQs0nF2uLV6tummxrctquEyTcORzjVKda7PWcIhzZjBA19kxj25u+v1IM0sgnrAY2bANM6xk6+pPcMTbuZZHPyHA0RkZF4egu0kLj51V2Ozb7WdLD492YqnFyYuCxbnYGNc3XLGiisvtNXWkqoWNBlUsBTyjLoKhavmOvq6Ghs4rtum6dYP05rOF5XxXd8OO3w7GWdRfgB5FgyrmujZryA8+dTXXTDwQU1m2y99wPLxyyZyyk7c6+yO93bvTqwwrsD1u1K0dLRHKIMZFe4GzB2hTokCC9V+JeXRusceEcKveEeo2MdXbC8APWanbJvTq19ym0xGJipqqbysuzTW5VjWJGBAwsGyIhjktePrLutPLpo6Wh0YC2Cbdy+kgDWCjdrB3bgkyMi3mbR1HJFnbdCae9fDY1o3CN161aC63aA9jyttne2bzfM061K6DCtVudN58F+SSob++4GsmJShnxsUbxtCvqGvkcyyMvU8QQ1xxzi+rpHWCxmRZdmtuhoewjbaoXlCyerwA9uZQTNLsNRksIeA87g3qPduk6NSCo69nUkjgvDVVzGVoJ9CNFPRvS8Q12gmBy6FmcysvtWDhcw47yutA0zYNcdV4N19mhdEXhbjRgciDt2TRgGqR9t3plA2ZlqgKhE3Nl0OYJodHc7KMQ3CIzm3Rs8nnzsX7QKs3vCOsP3w22O0PmoaJrpqdMm4eZRURsFvZm+AHsUXkIXoc5kuzcTBFirOC9GbUoEpbcvMx3hXWY4oFT1Z0y5tOpYc3aPCzmpuHt9YvnpdFAWDoQEpY4DepdR3C8dMbvY4S2rBuh0cjTV61m68QLB8APJUSz6leHTM9GaW09yB4+coDqzdXa1u1gjoblvhdkCpr1A7T1RqXeXUo0ZiMawjqGO/aHWJ77Ha1rHfbmIDGjkjkq2oqmG50vrztDF6raaHDLo0GIc3BtLLLDEmVXnmGyDKV1sndHmQvJonX3tWXKB4bp/hZt1rPNGQUTpBr5UOD+OwFwdT22dlh/j37Ztnvll9URvQZQofR5J19t5lxZiGYGM3kMRcrRtnK8Bx0Rddg6lHhndJ08Q11XRN1kVKyCMpNgQ89E27e7T502o99KVDXqotfbkzBqSI2lvy+Qtws+UGSvLCM10nrfbIRsze624+ucHDub2ag9uxvQYRl6+94D20hSzNvsyGKt0rJbBcaNPKd9KugTDIkVlB/b1W6qX8PlSNSUlMfsJXDV6Av7mdlt6D4nVeTxL13KEuufPRuTCt2c6QrOVxa62K7UuLlgC432J0c57C6+57YraVHaemdPqhcUQ3Nc0JHILsOCvuUaOU9SW9mYOevRDc1zhW8OsUC2smK48mTurdN93LHCaLHPudbWPBrN6K2B2qYpGCZthAxEo08x4+rMq3MPO+vdFMLbq8Y4b9dIkcBYGSUSiUSiUDioyJD+YMFkE/rBOttY8wQgRANFGByJZYVtae2DM4Iaq0RZJiXdrcYDwNjTrujMZCvFLF6ojCt6zbtAiefUc67uTKqsf6XzNiPBnzQJAnym4sdOPylmpcs/bid45XXXQYYMVl+blFPhbirW905o686pAOZ5Q81hxVyc+G5XHcFDfVts5fJkYPnzDKwoxSwvbWzFt0i8yN9BaMUxXkHB8yvVp73Dhu5fYmTk3A09J3sew6K1MNw+Cmnhzgw1lTVkl8Y2zTFMMSgBwzOj0523TE52SW8zEqJx3DhiubmzLw5aq8UE7uKfH2jE6xzNujce7uXfZlyJBEqLAnZvdw4VsnA2wiDasQu+pjLhzFnZIM9Gsm3qtJXfptpS46agFayxhuoT3U6Ac6tpZqJ9Mkgcud0lL2NYkeIPMSahO8g5WVHTzsU7cNTiFqk5WMfXfLc0l8enCOVZ5bLpblwUTmjmR3UQ4aKM7MW+jmy8ju3eZKo9PCsukKIvZ2obB23gpCq+zfqLWGdN+vDvxqX1YmbaIzY5IN13niOI57MVa3GLNYieUzMJ2dQ0xcG7S2W1tyhpyk3u8qreW8+07fcch2GU+nWFO6VfIkxZq3CDZAOTeNTC3Y5hLLa0CXELutUNDRe43vTThRsX1PSMNJy8McLzHsWcW16KzfSNaFu9tZlirm6dXo0sOjVWiqIRZKRssdmacsHRnmTSvMDluckotHE1WZLxzvUDaL2gzuXRElvhHxGLYlTGKoRae7ma117tNY0VTvOMG7LggzFuCaA1JUsZLulqmaZMutqKJYjZW27OJGXeuAkbiiTqUbhYQuriwkFWXNbGLR214AexnuGK93Bo66yN8Nw5U04NoOt3Y3hu05wKIglYZTWxTQ7wk2czXr3DcW94JhZw7RWCWaGCqWZX5s+CBAAhNn6QPEDl7O7g7Ct0R12MMWsmuuzB1PXqzpswOa/PCqtOJAmtNqAW028EX00xditB06tM+mL1AMiFTExYQFcm3vSs7XS2X1qZcs4jjqS7yEbYsIPDW4Y9QGw3u1w4e16MrMHHH/PKtdkZ98xjHwMLaU/n8dZ8xyrUkh853wzr2DsHrBpqmQWNT7KqX2YasMKdOrd7KKwHMjJhXnqma0FylE1YVGaCsDodL8jexOhvUaWzHTgo7aIQ3Goimd2NUrlnMFzThSFmZA6N6uZXMbQOVyZqs0QPDATNuKhfdDas4McztwxFVoOdApIl05R1indtGuzX0W11CnsvMuV5zrkIVLjErS5J9lDJRx9bWjDBpNWVTq9WcS93k9JK4u3l2MDgl4quKWyteNgCiDV4mOYlYnfHTY5PSHbaGVd5D14BQvXYzUlmc/Sw+GQkbdmlbzUnocLCeqtXZGjTVksnKDCxu6QIsmZbxyRqDStoECgpBmnrG0fSZedUVmcHWYajmTD3Y2J1jTXJ5bm9QuzrVuZl0r9FlhP2VZy8clITShmlYww0wY6DcxXQ4cNEgm7mHtwktngWb3bYyqvWxJg92bQg2uzKx0gpReLpKjySmHVynVEPJZemTs0BXeEVWCpPRwoRbtSxVVZ00DVgrLtem7ozRTrC85xw9s/WSPe+U+915dgn6gmgNVx0t5WZO5LnaV60k+k9VV4VnOBmJvYWCcuKs3Lfbo4VsWRrQn2XWZiMofmDOK+Iv7j8Pg5D9ovujZbAdcbQqEh6VlaVJaukRcDDwtyMPXjpDMoaRyO9sbEGWMZKfgB6uwZpMIrIfAD1dX8HezEjcoJlyiqWXTRVcaeCQj5Y9RyCqmVYx26RoitkCl5ImMaeY8GunZse+Y0102/eqvcUWoeCnOVs7tek4+02DfkWKLAMUpi3G9XI9drcVEWoGjizLvN1jLiFX0Wv0VKHR21m7caYgL677sb30zMmRmac3LaW9tOPR3lmc5KysnjkDynULT5oeTkbl8lldc3rs1si0K7pdtuOnvqqvOsk6hud3PplTFtnd1QPE9s3chvc3QKfJe6a+pWYK9VenWttvhSkuacy0p2KxdPsze2YFede89aLLGF4IDaf5fYYs+fWW9F/fGwbJUzM9duGAlB53arrKuYxemiw6FqdEJ32zNE8MMyzU5IZJXZuzdypjXykG2ElszVyZOCsq5lDGpdzU5lK67deXhgkLJ13ybHdtZkYqLUNjJ6aM1XQthblDos2s8DpO8ZfDMGiBM3ivpMqZkp9Qjhepvopzfavqpqu4ebPs12K4UUjo0ZezJsYV1N+rswYWAHVYx3I0qQeXRst9uylU4RB1hGzm5jRV52Q13d0knYV7oJ26a4ztFzewdrF1e6RF6UEr5NmJGx3DQxHYz68vPg1y7ZS+TEdefxM3bqB06vgSa7rzJ1xDclSs41m9tSRZOPCrNy1syITMJhXLeOm1mRoIILx492zR4D2Tm2ubidcNgq5lkh5u1wAbN8Vg7MrbqQMbUXTuAIFE7bvEOziLWvTaIe4O89/T4cuJPTgevDixxmnqqBaaoPQL1EM9fv5+3xdMPz7j460jqgc5/T9CWKy5QIx9nKsw7tB1OqooJO2dN65u8Zr1cXEHns3CJj3Arb9dFQZ7CcJTlpq1MslM7wS2UhZQU5QHPADxgb3XQjbaYWYrW7WPTCDz7JbtTNzDZSo7aFdm6E9HbHoRbSIsqnUFdNBq+xVbyopnbz2+rhOGjO2J2qmR1yW43ns05ROia1evX1XS3lmrCKzYZu7ZmdGN2sCAuzRChP8XWWre1gPVZi8APURAeyVIfqmGjQthrTneBtQ9vQX7XTIsrFDSWHNXS5uaRx18I3MrPcpKgy9B7d3TzGjZtKXiTs1OLkvc3M3PmVKumnm0sc+laqvPqSoZyejLFq5C0lj+11e51DazWNfZnUyiy+0UkNeVImVeSrrMG46fEcczb64uUwUby/Jdi3trhxgHZGddqBTJ46znq5hXTNKku2G+xXk5Sm6nCKtET3KnIG8K9HWXyMSPaSVXcN1YNdpiyU88xjZxctvMSnYqDF7TAOo5sgitirFBRvtgQrVt2nlumbFOcNEGyhnIHN5nHR3e5OUkNXUVThBvO16E6e7kZJVgaL0WrV5SOy77iHvncvadadNAuFai3T6hoejcO7m7JyznRy4NMgJYODKpZLh6uzht46aTkq8hzudlWdlBwQqHg1lRXtm61EPb40xr59V4/PPG9esd1PhuVndOUODdiW4gwz10+zJWhisKtwirOzslncTVB8bpc3KFbN0To9DxWzQgsVDcJvbe7NkGYiRwuOdprBeSXRjpdU3I+zhUubl3R1WROwozMqzlIaUxoeLAWRodI+Q1FVYsXmUgw+hwQ4aeIS0XQebuaby6OtczTw9tXHhPKiF9ZYdm3iK+nxqBkR2mJAhros3spWCsbNMSOzVtQfY2JzyWG9zHfx7T6Xqq3pUD+u39ewLd+ebspwTnGpesxC6xL9oAMAAP7AFf3BEHYrkqthm3jMxLqquZbdUNJXkaNLpkZDUfM0Yx94BI37ZGVCqzjhHlbJIOlPszPILIoZXMh5g2fhIZnPmFPZitAhCvVXlgr1V5jedCZWb1ZlXepEOPahlXyb0TBi7pw62UMmToL7jvKgWoQ1lGtx6bmus7XadTNDp0g8nkMbrKR2vXug1nCYd1HtV7Ext8URuzkojEnKmchtrmtC400szd1tbo8B0RAl8r6cguW691cOCec3yFZjlzwA9E97njpXkYbrW3gb6tvtaZxZhE0SPOnCEtHlg2kdF1d0m2Bndc47Dpxzh0bp5d2xjFG1q/khGHD8OVX93fYiO5yr4jM6bwGsZgDSrVwu2BljmS4mTYPQzpyaZ7tFZHtC0MNyGao6s4Wx/JONXH9y6P7dp6hdHBxfROti6tGWbrpJG66u48BlDKO4mza4qWz0pRzCznPsOS1WrAmCJBOd23V9vbgoVbja6zVyS9sSpbPDLsMTOVHNXMq7HGxzB1QE8FZOGze0dx4MoThiQ8unm7Ch7taizFkPBVL2kBVZ3bY0jJfdIce8KED3W7eqnF1sQRY7yrm6p6qr11BW6Kec1oucSwg32Fg5ao6MHJcPOiy8tO+vQa4HmxDMJzHN2bBNWjCkLgaqSuu63qMudcyARnO69yrzcwPQbowYINscPpOlHmDX3W20bPwEYvEjeWE/OsKLCtSsjlD5WXksWrkfzd50zF1ppV08zGr26btjrcrDhE3xC4J4iswVRB+xyvvqH2rM4nGcGx/IxDL6aO2u5O95bGctvFuveUpPpe3Frvt3L0jNcXGlyA+Kj+GzBox9eq2huzPtriqupJmF9UNEl9tjsEwkUtWLN1utd3l+LF5mmMzlFeOosJRDWK9OM+L23liHKRR6Eit2HQ1f2VuB4caWfRk185kurzVLz7JBGb088wgnRcc7AUYQ2LF41wZG09lPHb9o8gayjyqVBKvs2+KrQ6x5o3M7KF1b3t7YItWgxqK9ioY1xpKpg6Beqhaqubu5SPOeAHlIJpOgpY79NQfXKQXMbs3OsyZvbp7cD5Y964AyqzHViLtDQy5z1qbu9tffKu9c770ioIfUBlo9M309upTUipSQd7dYYPseu2dTrefXPZuUB9Zwcqi8fXonY8uA1ePjYcS76d4O/iu+pr4UvpgBmibZdHnb2bRIOfWhVnOzvgvgK5buwljsdMMYU+7fYbW2X7b7KlLJx69U18nrK1wYGsibsN+u3LyzckxxddqsuFpwaXXiUbziOsEJpyZU7E6WpjTRl9Y5KIoijGKyncuZt9jfTIFYfXzOeitPU4VFSqsmvxIHS3DVTG6OjBxLrOi7BMYb4FMwo3tdjiKo4KznaH31/CFZO0gUuGZ6vjN6BOkFtp9GFCZvdxdKwZk3DlDOaEY1S+2dKF1M2PSOXGtsJXuUIKiQqW9jDp1OSsOlqYyZqcuqzadLpq2ZQmc8jGdMlG3CF56vLWVOyCbD27ENLm0byX2VdgYa7upN9nR1UYt3Id3JDcyt1vt7dgKWalebtaT0GFb3PKvV1OMLiVIcqXjgyXgzrcS45pm03QyQbiKHv3S8fBnxPiQR4knCRGTSpGE0Xzvr58/H4/HT1+dYzI6Eybbu+DWeCMhOUT3dDu25ecMMovnum5ryiTxh4TPMtWh22XcsrnwkJEwSRlaTQuhwimcrGbTytqXnOt5c+xVxfEUNipDMwJoZ286rJj7RRvKLIU1vbmd2Tn0ure7Lcy+zdpIDm3+S4du6Ll/UPooNk2hCezXnwy9265aTus0L2GRy8XbQ7ZzyxOyUVCyMK5wGHZGxr5oMdOW2Yl2Qd6OCpkl0ZCLD9Oy50o39e4uP3fF3vzyz9XHJhtCXFtd24SPAeTgyhQDGXp10X0jE05NMyNeBGdxm2KV1Uunklg4bCYZFaH3SbZbIe09CakCkip69ravWhKlaQyV3Tq7lM6dFpNvV09hvz6vP2FaswC6OpxjRhDuM0yoDyWBIdJR7BdULYVy7I3ry4grRe9nDCFt7uXVTONuMAoAg1pp+hMROUoQ64XfCHpGogSYOqZOHqqvdXMVYdAVJi2LhWZo3uUtIQ+cBCh+N+D90PF9q0bcWdN++yr+RFRxS9VvhekzNezEde1pGnI6T0ayLtonK7cidg88AcHSVssuzTrQrMR3qnsmxsMBFhmi+6VvWbD4RSVtk9m1dxbm1IUbssYQsoC5Fl8Mx49EyzBfFiR882q8SidQyGdfFwr2pyXxd24CVhOxC9zrkFEQkbS57uZxDqKiaHOpKdIQlRBPOmVNXWyHkVvqlpw0l9kGbomv4GqNsT45dz5hPJQiUy7mVMV7osIffXRBBK+K7kTtihSb+QZqp9IKhsuHCiRpZjX0E3hRs4zeSVu40tu1i6ns7t0SqYvAyejNyiNKOWhPZdKN449MvgU8bfsSu2q1tVdX3bnPMmVzuk8L7rBBUMW3dTczBebkO5MqxsQU08s2RfPNBwI13YU/e+9XJy+W0s7rzNF0KpHKi7h5Cu2L56ObRU4xVa7972A377nma3CbEyDFHkEgIEHc54yzAQYHDtt5UWOjBHQDQlZ/KEVzp8nYXrQiA+FNQub+eWtbWNxv1Xeur9odklCRleZbrrwjhyNsvUe5NbmOKr9n21SCgQIIewmwEKB94CZWE2iSZizraqHw0v3ktKz7nC+EM+V4WCh3nl691mvppBwlFjdwiCC5GzpWno1yKrONy8ZK4bSrHe1lCT1VcABCgCIfc4veMEs3LVFlVYpVvzzTG/e0IQ1c0IbVIRzjWeV1rWXy/Os8J48xaxed4fISUsgPVdGXDu4PGqKHjuECAQsd0AgDCRBvaoAXUHnWxnfOu4d8cdS78CIm5EqBUqFQqFJUk2YQwigVElJ1J19r4XusXshn7+ve5xgtPZ76iEggoC9gxRReeUMgGT9r7tl+4a1p139eBOqlO3NstsqraWMiEBUhhE0TAWN/ncyVMkkll/jcpFiiZBkJMTDFIkTMxY2WNjGlmGaYf44GakkYEmmZLEpooRDu3ZkzFCZICJghjMUYZGJGqwZhQSSEIKRgikbq2tXdvx81Xl4YSQoooZZLBQURBkEWFEwMCQyRpSUzJSGQGRNkMESNQSElJMzFAt67hBojSNMTQMpkoiAtrEglFmkCyxe3TJiMEIZBJJkkQk0aJIwAhnndGGkjCBIy9VutW5MZSSjIMgYwgoEyPV3UpETSTRpCDEUgwJhihGsxmqyZTJMpNBImqwhlEEYqRDYwosoB3VybJGCEpJJqTKJmUWju3BISTTKGkiPXXSAwATKQyLCSBQsWZiGzFGBAmAMmTIzIxTDJ3cMiZeOlKNCSMKUyWSgCYsagjJRAKkZIYIpFDGY0iAKb77qLNenXLhMSQISgxhJCkRmJQkCiGJgJJJlEsilISSiaRSDMCE0jZGKCpmDITu4xEL01zRowWYVCIEmiE2rIIymSIzGaUSTRQsRLFkAUIp4uBokJlawjSk1WIJhGiUEiDDAvFdFF53REMZGQJQCTAoZYkIBgExMihMFEIwvyuv1fnt4mT24NJjm4iSZaaCykMgmaRG7tdBJmSCYr464aUzJCiygkRFNIa1jMZIkiSYFTHdzJJZNDMYMhmmJoJEiCJkpolMwhiSNEoUYFJzsyQSiEkShQlLGQSJTSEyxsiKSSjKEhokKmU2CNDYkSSDGRIwhNid3NCAmiCZExmMaCM0GIMCZIhkiRjKUzUoolBMZJ3cMgpokSUCJCzKJSg0g0ABGMKZghSUyPVb+/r+df5e96uvz584IMsqKSZMkIUikAyMyCRBBGZAikYQSLVlmQgi/C7+O5KSWwUWrLMUCQEglKRjBCmYKYIZmQFI2FEqFGElEkNA0xPy7GZoSUyDKUMSRSSiNExo0mRhTuuMTFDF991EUjCaTMGSEpgIFhjRZmGSEJCY3ndmMDRkPeqy7MmSZKP93cZgYsRgYkJ46UyYbKRI27uMJR66ush4t0KYlCedrtFPF2ZqsyYQxRRMUYkkTEiYyYkEhmNEYkowmUIZmJDJCSLBkiBhQCECxJCmITIhhQyNqyTKCEm7uSRMlCkJkyZKSmJRYpYQTIQhpSiJhhMDISWkiJfPc0AQPTpNgxAppomISTUGJEBICTCRZCJBQYpohEjAZGMz+v1+/XpH7bQovj8Obl7/qpM/r7xjAn3Pf3qyavTz0iHH39W384781xz731377zd8VNxSQGEIgKO0RTiKuooSAgyCJ3ENoKYhmIG9h1w461rTWYjqoccH7oTM0SIX27DXHjVZB5Ne1rozgve/G+OKqndEM+Oyw/O5MMgSJCUkEImiQ0GAJhDAYzKVMCCRkBkjTCSZjNJJBP77skiCMmMKSYlEZIzzt2QyNCBMUgMEDKKJpmgU0iRCBIAJTGxilSUe63XZpEBMNCYwjCkm+d5arqy2tXm5LDBBMiiBGmaKaEhQigHruoqEoRoyIbm6EEmaZiSFMpCsUSJE0LLEwgiSZAxphJubhrWTRLu3YiCX04xjJIpjJRIzYhlDDDIhRg0IiERLIvF2aTGEoSEP5dQDDMY2JJhQyU0hEU3g6TKJGgqRJM0zEmN8rkKSROXIIJGREpBsJEPOrpNPG5kIDL/XXAlkjzuMFBSKCZHruRRlkyiQiQJAxGTGaRQJRBSEppJCZCCSglHzW7tfP8d5KAagiMIxgELIoMzYhiATBiGQzEykj47gSkZpRZhU2RESlJJizKSRCR8OEpIoKhjQikWaSSBZY0yuW6UhsIiYSIIxIGUWJRENMJmYkkkkCRZGIj4rfz15nz6releqy1qVlanqGMMZCESURRKZkwWL24YZJkBJCSkyUKEMhITKJRGQZkkGQYSlFgkExlNIxFI2ABmTInm7cgYqMo1rMaExIlsSlGJhIR1U3SAYiZkslNCFKAVbNRGWzUF4bIL6MRINV80Oc2gUhJGRkZEhRphJJQUELEhCmiZZKZiZRKUsMj57qBCIiDKgQCKUEmEsmWmQlhJoQUkZABIkMZpRMJn26ywhiDGFgmQwyEkRJIxoMJpQxSLE8y6ZGFhDSAa992/qv8hed2N+NVbxVdQDtKklSyRCiVKlIUlKwH5z795+b629+89effdgDYGAwX0FAeZhzJAkM0fco5IUlJURJRgQGr3Cb0pUR0cqWycZ3NXL9+8gHu0n3WkypBwShRKbd5Q2x3xuRLAxQHhFwi3REP8w/qkZGSSRJCNBixMxGYpH/dMRZGM0sjJLGJjXrev5lWq9bavULPYoWAFJTGYlkBippGoYt2umxqMZSMTNGkjMluVyNYnS6dyV3Xbt21XS0qsUWrLZImLat20kSFj+EPSHk8HzPvnxgOPQH0A+fJcQfvFA+VMefeuABz5bXxbyz62CAbjme1Vd4tVXewLtb17zgJnOcvz2973vfvcHOVzvO+fK9xyt47s7M91XtXo833vZ9vw7Td73s+t8L3o11u7atdG/X2zyuv2/c5Kxx+c53zZ4NZncc749rfBteanvuDHOXznvNzM823e+w3Oa43J77b75znO+bmd7XvfY1rm357W4zn2+tvPtc7n2Nd7n169z3sb56ta7eJ97MDuodxG7hEQIiIO9vPa84894wHFuFBUsDYOx3DEMBmOuNWQ773Obl4ooJ56m2dr+xJJAkZA6vn73X4ndJ5t3oS39jqfKtq22xS1ZRJBRUQ0F3r5v1fXWr5Q71mOxa3hm+uPbXS/FCrwoLtQC08QEMJ1sQoA4EIE5ANPlzsZ3jdxThAgAweiKWK9EWJxAiGYEQ1AiDp6US1GVVAiogRUMnGEW5EQ3b+6/WEA2UDyJ382qQklSSUQkjTNwO4vK7zxzpXLyR3bzy87zvPPB253dC5eXm5CQrrvv4qt9NVK2bZgIxA43JrhatWmJhVpeuYnXRnbh6nS7rrsmru7u66XXXLddijAc3XXbr3tVL1gLcxQ5IDoxgVAd82bBtfkvFVX95Eg1rZto+AO+frbY2Rn41l1thniXbwWshfzoXzKbx+PySqJHF+hWLSs7XRJJP4zM+301rVvt454/b6fD+njnyr+n4AftxQIx2XMFj0sdlW1a2Is5KbKnpJckk5KlEY3xc8XRHjg4KJ8U6XKCT0yUY9KmCTkqUoqZOySpby0aLFAmDFLZ2nloqSbOzTKxJk6Nl9rowXPTBoyfGySSSTRQITo4MGjo0YpcFEzxWMmTs7PiSTlVJRJOjBTZg2lr4yXOyp2WOzw6LkkkkkcOD4ubOjo8wuSSpJJouYJOzGciogkkmyHK2uDJ2XMGijnpk8OTBJ4SSSelzkkkqbNnB91UyU2e2uVWTBo6OD45OjkwXODkpZYsSSdHxwVtQmCShJ4bA43l2gEMqAUII4mbD/fffr39br7+nD9P2/T4fb5AAB/4f3+fDfD7+e+/rv6u4AAAB9fdtfK1YwiYOhv7F697CfhOZ2BdBQEcCmSUH5ACRQOgEBiKA/EUBzwNw+QMmuInla25svB7zanSe1Oza3wJ0AeQOnioQhSFCqAtlS3Uxq+xLWpHCIZiNAPvfPN+ujqSsb+im3P1yOu88k9JJJ1CdcnfRMZ9YjjN7Z321mvKSlRNgSAwBiMAROgYgVKkSkskFJUkGlQnFQRweAhv7bYBX2KKqai9A8xNRJ1593ynBIh+0CId5833JOCUTnbOomkPjEhNfdJpVqqpbasW1RBmf12uqKMCTIpJTTIbCBk7rosTZICGhmUZlMkgAMJiMihSKMhzdMyRlMEpRJGBM0TRokhBKISwGEIYjCYMyKSymEgCJCRiBMgkiww0iXdzRICaFMiwshA1WZQk2mxSaiRMUyUxsWRJEYhi5diZiaJMSZiEICjMiarBBf8jhQyTI0MiDABpnndIhNCCjEJMRSkkhkwSE2RRZNNILEMkozTCUyCUiSRIMwNmmJmSRAmTKbBeu7RSkQozJJLVmkybERMzERDJjYwLztchGEhkSEWYxtrNgmASEgYghIpREzMChIYkEzI2UkwSZiIoZhCkskRMEoJMomWrMhtrA2DeldGkg0w3ncyTBkiQK1AiYYESbKEzVYwoNMkpGSMzzrkNIbzugGjCI0EjSIrLNAilIgojQyQiUhIgiRUlkMRjCj67jAxLKJMyymEZESNMpMEDBKV67cSQyjRSJhiURgIJpSR8d1gJP+TrkpKGglfDlM1WQwCmI2RSiE0ySFkxmhmIkkZYMyTFgwmJJgoQhisYjSQ0xtNIkMImEaZBoRDEAQpNKRYZMYyhhBSMyChDutdZMjMkYmiTQIoRRvjl89vIGUARmJEkyGaElkiQlLEGa1j9Vq7kykQQxAkpkhCAQllMJGaCTEiRAiC0AGYYSYGJqsikBhJpImWIRMpUi9tcU0TYV9K7YQ0REUTQTaskoopMKWUSaYY8cGERGRTfyumgSZMlGgUhAwMQQJCEiYTJEpkwoRRMiiBiBKmSQZIUhhKCRGDCUaQAYoSaRYaRAKkyR+XMYiQmCQjFFGm9OJFKISJruuykBMgSksQRmNqwQzT67fn69XmIoooimn8S5oyWXx3YklgowZgn4XRSIgpQkgRYADRKIIoIkSMkJGAyRppFCkmySxJSINEEIKZ/Nb/KreeUwSiSMwwizJQxUiWKBkxA0ilNApe+5RkJE0IySSigucvn9fnz0BJTJJhjKImkpQkBBFCGECIhsiBpGBHtXWrfTtgJZpaszeOPOuyUgpmSTSJBszMJBqUEUTSGGGmMNjSCXddkQIiFKJKiE2JKjKUkFExCJGRJAUzJjEhJkeOIF9dz5boTVYJoiSkQgETMhMEgT2rlk02FmShmBJS9q6IlMighEiRhoiZTBpBSMiiMmJsUEYZYSUzJkbnZMaSTBqsMghAyYCYNmTLu4RFCYgohqSBahqMkGEnHgO/zy/POD8mxgz9t8NvnrwwYIBaAsKa55+feO+uO+ePPO/fSucvgIg61zNXLbZOOdziMovnDkAedTSs4498HS7avv+fnzUbbxfNJLKTRf0uiBIjIUySjYbSTJEQwbKGgN3XYgJIBEIggkQJMkX9uhGNgNNiZE5wDMmMWSkQgQyGRFFKYpMpQJohImU2oQkhMmyEMZZowhmMpRKJjL+qrqt1EJNVkJNTSFqxpERjJQUjGSzzrkj13SxJ/zOFDIimppJikJgZJDEosgwgosokwwsSRgmZFmJgMmikNEkhsjAnvNcEphT110BJppUjMZFJCRATKBJI5u08tarOyYhiIxS7VtVtdWed5sslJkUiSVGaMhjJMKLMFCYo0aYyCUucTQMo2ZokSSBos0CYjAzFAsiCAxKEJIZJRmUQkh77iZJBkSmSJoppMyiIQhQYxmihMkxiMTM3qt1Wt/l5XNkQygNDGTQQmmTZQzKiCLEel0SmTTGDBChkFMtWQQQoIlM0mZXNcxEjZYMNIvbqXndGmIEpMoUZepuppEYiQ0ooiS9OQBSQkKJKEAmhmkbnQQFIfunaACimmMvit+Ph6vR896l5GZBIkImaNVkQyQiMmM3z11EmEld3Fkggk0QpUmREZpRMJqslgkUYbEA1JiUiLnJkpCygkzEkkJkKRNJpGTCGEiMhIgRDYZISlb110Yzu7RkoU3nW7CaRgENiiZkr41ltvx5f15Wt0EaIUmUgREFAxACZEIlMbFixKQJQzA0Es3txhikoCSplGmTEjNLMSJGQKRmMRshhFQ0jE1IkxlYwQVETJYVCRETGJISRpkkWKCYDGShSZREp2hU+/NgY85/Kt7t3vt71z38/PPobiID3VIAYpPqY+eyTjYmAlRRPnWCYikyQqd1iSCkSkR5lWDKKmtNM6JSkoFJ/CUmBNUmCWChAXiNIpqVDrmhCwON6BsDjjRm4rcQVgOB6hQNt6EN7XsInXVuC2eY+tvqp8FAmFxoJxBAQ8sjtqIAI0V6PpjL+QIBLb3asnBAGkQHkW+9Oycu906MGceAR9XejBjGijRRogrJiiojRRQlEZ/H1158fX69KAqIbaAehFQDqBDaIBh97vFefD7GD1u6m5A7qMTntV3XTlwfewALIJBO1QvGQgCaxRfkNYeY99cdJwbccVUDGhXhBAd1fJJIkVX1JJJTBFksoRatT2d8BU/hFBHTHl2e/L8cNexv3jziut+9Zv6ZfUL31zg3rve78bdD7ijAw9LxktSc6cOH0T1PKTLfZjxuTZNJTiFybEqY1ZKN302e6u5wblwwIgPYdeQoYRaprVuy2RwM3uM57vR6Fw+V10YoJhQnOBAiBt91JUnxz9agTlI6NCqqu1hpsqrBpV4AegQwEVYK/LEGoSxW6xxe9sJ4l5mPShHCvS2rgHOnl0hKjPXUedlsFvdRwqIGbHBjo4M0Z3JmXyRR3KqglGW9wRNXdbNVCZmagVPR+vnpoc3lbeuTcsW67OE13FmD+yGdXZeETax8bZd+mnLHxFVHu7dTCdw8iJzFNTq0YRHfRc9Ma7dJCyseDUwy7CSebuB4KzcbKariSLuUrRwm3dm8ztRoYqEiLNWGmNW1WeIiiDYqxThob2Q3NdbsE8fWbRC81/WvtQkePdn2osObu5VOzuTabJofdxe9K7K4RM5u1s4PN2jYYcHaeom1yLNt7t7htSgO1SWFVmPX93MXQ0prHgpmzcKvbjjOPgj9RJVlqse9XQy5NtkGtxzle7xat8Oa3ckDCHY3h9kW3bmqbC8vcO25QtPTscjq3akVkp4AcYnDcCxV0pVu6yNq03JFxeqS8W11Y4zqp5Wdo0hIUbGZT0IUa6DMyPHE9ztvs4VJ2a6E5YuB0UNenKlZaeBLkqFJB5NTrBpj3jR1zAHV82Q1lWW65ghsXmTpIVW6UTSxahmm8MpGdKQ7c0YfsL3e+H1Yn9PspdFV4xki67EwFAioNeAzkuebeJTLtKrT16LsM91bTu2Kawcsj6zSvtkU17O4yyxdh7gNY6Cb7Nvr16TZLFYlTwWiNheOW7tWqQrUyTq6hwcjSkd55Bali3JuDBMiOrly313DsyiX7MeDXoaxXIja7UzlvjxAYmDEIazdMybjBxt4LeR5iENDsWo6WPIisvM5obtKNWrecWXJigJqFqxoboi9Km0E1zzZYzGt0bzqUg2zwgW5O0gPlVh4WWhaqRVkrd3rrTNXbhK680rLm5EIZeJO7wwMU9dLRnA97UOBuGw6UGPhs4irDRPNbQO5jQybGLWnJxgO8RdOHrGYgpt24CFdl5tPaOZelzVRu+3ZI6mfH7Zv3cc+z62X2oFeqq8OobeIwgkS3mE4Ck9q5t2KsFxlvc5OXtvYhOi5bEAMOl9faIcPmYt8VzLKuu6VKCU7BEMsFrn1N9A9lVasZtYubD6hSsvkcCiS3FSaGURZ7YG9tx6rVGPCecpXho5m4sVZyzanF2XhtucR1o1I7y8dJndy3TCDLVaADmkMk3Ot3M3q1iROrLxN0Max205ZRw2L1Vd4civCC0I0sZrdI23GLVTcbWyX6xrIVb02ia0biUDexAfSvq66293cae0KysJjFWT9dguN2ctfGfdomCqE5jciZvOseA8agR2XlPTAaSzIMttKZQyhlY7JwsUXB660CXbAIcwFSxp3ag19hHHwFWcVyPx1vZzudEUedvodupbmGt3Ny6c0OzdaJbb1ywd3QS00d1pbQrccB1KJ4mcU4u2Zb7xbp9RPb3PKB3Vl6Atg2uQaDqdvKVkeO8xBGxJVnMtylOGA3imTeynnb7nD5sAE1ZNOD4n5hYAgvtJrgQoyYlYq1WLXNQon8+1b4o6zkxp9PAUVBdhe6S9zB1hdkWN2e0UdmYq3D2jZQlI4Kpbo7uWsgAzHSTaKbd7s3RZxE8BABWCZxgzAr29EooDZ6YA9y7pWbhcCmLr9NTJt7QvtUYJmXqHLeriurY3lF7fKFXHDu7gVRcMZS3ZdZg4zRdxbrzC0xNfbkoVdZcpLIr2sfaMcZmVMpeW54qOslvrQyc1p2+ylK4QpHMT2RItUCdKfaI7mdenZasybo5aOexOWVgOJs5RQVVk85kBur3uuC+dZSndJZQxDL4QbWmUu5U6uuu9dCbdHNksMF6B73vwD3AI0RjLM6hxa3mHejunDEXNORFc3LXYvLBpJHDO/I7wbdrus53DLgZwnXi6YaZOPh271dXZUSI67ggVBrecvEJQekmYuKmRYCTt6ykEWZ23x2uPVvfn0r7cGQEkap9OpZUkuJF7Uw2bs4c+vKEpx0IStEL21rOBwgfGEYAkIDChbTBWrTFZv9Yj2YRUjc+raoLKozAoVa88WLNbZdOtGBywF9ZVys7C7fbR56QcfXk1I57apWr0j86TsKy+f1BBG7ZvhpzNhyoQLEMGn49oyeL5Zt9QpGXbmu4uVuY8UYrbmwKsJca2+0cw+u+5rgQPdz/iMUjlj4eenvicsY6OufGrLHPEpjmgNEm310dnM1ejpOvqlgLikCkbd4LpUo9faXUZGXQ3LFX20C+kGQVG497odu21MTT/CnRdc0KPfJ2Au+dPKQzceMUbTbwVLVZRLrRlwQ5F17928uRNmm0uMsyWJ89oQ6jPpuYq6sV90XYN10e1+hqCYYllEUbF1uVE7xI9qbqoMBisxunlJ677eCZtZzIgmITsG0JxraPduy8eK6ySCnsZlZr26GYzhw314xFqkqYsZ6VmQoVhesZid5ReLlVS25Km1HfBuvAD2XQfgB3mKq961ttsbcpsIdD7w7PTuD+A3CA/NkjsnZOE7JkqTJPCekkpzBon1KkTshSZJsmBFRSdE4E3QyHCY47ToTJsSkp8JyTglSOEqRFkKiNIcE3J6TJPAQaAT8SykDTE48AxV5iH7hp2CLdVYahleTicSGcAIiOCiIBHVy8sl4Bhnwxlg+YL4px5ekCl9JuG9VHbOq3OrLSzlmYCoClbzQPVVeihYsMetpS6lFqKQ4Lq97CuzCIOvRa7ifOrJXWhmtC9GIwaOfqr0ZCzOMKU5K0LbLTHGWuiV5hatoF2Nz29o2ODKh19g1UDW+yMd2UKVcNG6XMOSTLjqwM0I0S6ZMGLiaW7xxRZWl76qr22sh1Y6mDawptJcoKcv+WZdj4nuWXwrEH9wcmczh66x0Ueu8vkHzz2tZq1kESxSSpXlxVZblQ6LzfJNqq9NkmWod3zeFzd45dXtKJeeTudjL3Sjd7na5BUtoN7fNWcOUW7U/kRbuFAAdRqdgrjcwfFesRZXry7qXYUMFNkKo7lDXBUyBTp2F6rW1iNykUh5M7r3tND2kx888poNDd4XAWRcHPBOZGDDkhvDLrMvauaVYDEGXbcVcqgNBDND0zOHNC5tgHE7yudxptuG6WZNW2prmir54J0rBBo45mrarAzqy24R0yrnxlZwmrbxUMXo+za2xIpqnsTTCSvVpu8B+lmpmDa3NtCiYpE+ChrJLLDGyXpSlk2Oytvc0HEuvOSzXlzrrut6e5ZwHbXdrRWmQJsvt7rp1aow32k9agEIGZ2SOuDYN1QnFmsfklUqnzmTusX2PpsUxOiK2uYpSQyEGHUhES+wdlZTyt9QrrCE6g0DMqtzFiF5dJ0DkmclMGlbRY3KgNgmEWzrNyblsXK492PIPXg43sxPO3CvGzEbmVy3nLra1gai9qPsuCnlWMKHATj7QhJUWkkyU1Utjb85OQjrqw55W7KhwoPTdlG7eCjKEuBuN65rV6HLNpYHz2I813prgWzhl1e51LMO0+sPZQPA57lHtUW9lOu30zkc7XvBighRVN2dq+bRArmN4sb1qs3l3GtS0YWnh9YmaXBkin0uamcGF1i6BmqYEMzQxSDGfbfoF26hgup7RHmzAoKvFVjMrBljVUhXHePRq9upGAdhvQKtdbwdeyTXMAOlncoQ4ep7tAe6jt0zTKOrpwK0NnUT3NbkHqB9bwcuR4VcrQlFhUHHLeTqlbgm3MMllJxnHNV2M1bE7t8wxahpmPSi09XqqvSp5mE0hop0XGbwWtNICEO4MFJ08j3jpcrn77fhrrheOkB90r6OaPQu7VtyxZngFhsdz5Qwje7o8jI7K30uLaWjjKQpabfVSIvJqjWdO16G7Dp44TpyrSwXGHMVrBVQJqizK3PEY3KF2pk4tF0qOSm7aJ60K6BIgz1PtkjgLE60DYeZlKETPFQ1w3OF97r2RmiuQwge5GzKeX5nM1Xd6KXc4GZw6QqFc+zReDKJ4cLrKMq+o6NSukJepu6lu/ADxgnTJT72JUCFm3Ec37NDv1uBfA0Obec8fwvhTYwTaDjredY4GVdOaxTxFJ+7BhNzmLelh4ZmcHqO2Jb3Ql9I2RZ35S6pz5dsuj8qpTPa7TLX29mRw8ttmSSVXTfq60L7NYPYfXMvqliVZYStPKenQyKtfx/KH7QCpM3C6L7ZZmZQrowNydYg4gwFabuCXUQzTNHqEzbR0DMebMW1FyCBmT2HLPC5l2eSktacuznIcszetLurTMC6CWYLvDFKuXD0wE9p9u2wtJnAOPhSTFp59Ve975bY+0v5xQyDfvtg7QMqUr2pcsmgS0S8s9UsLyUsw4ei0GTUkyFxAW1vcJKGs2xkdXHOWi93W93gX+31j7638B9vanSt0fl2yVZzOIPVkwBA4dru9NhzdFb0EnO/k5pQtn5Q51NgK117f07QzW+wVnEp4aCwtnBQciLhPBxA5lDBKdq6Cu6aPHWL2YZf04T6brdbVsHrp1NsT57yzUg7fKayURqVuDNo3dp7ClFqie7eV09ZPZTlzhOvO9tlLA3qdDZIfblx5tbleDdRq8gt8RYnFS7bvhBu8N0yVCaVJBLM3auVkeyOwUMNPhseWzXBbYgmq3brog3qyiOij161C07tuIggUtvtpihbwUGpilEahmydmYOEk8aOtU1fK2YiCsabhve27p50vhwm9l7BhxSJZm/W+8raYOo/aOPIx38TpxaSWTb1YGFVihlFM7VEM4Dhg5lt7p3tvMBkLw1fTLxS8yWB7wFZpbHbMtOpbvKYw43J0l5RNBjrK0jq134AevOGbBouOmLSdryExXujHoiVDVSBal9Fjt1FVBs7uicJ0QrauM67iy/SlMbuWYnbj0ZnWfPzvuIV2jJJ2mxFtWsp0Js1PEcyj1KRq86Xzz3duXRDoy1HvXYvamzC7CG6PDwA9/AqvL7ByUeP6vs7HKt2iIKVbqwTFJW7cf2GmM3Ol5vNk5rDPjVN4a6Yp24q6buWzqFOVKvIzDQyydLWdlvUJ2mtgRsaFoSa224kasZt6xs7vMTBgmysQ0VE9iadGPco7WQVm5qhzbGIXo5hPuqJ1gxjVGvKAFUTAKwULUDsDAb3fhAEoACWl6QRGHgsjrg5pSVy11GotXu0CIK3l9W+/fz9/f9179fP6+voYDFBEZMGCBGhJBKJIhJIRTTCpmBGS0yKST/XcailJYwmMNFlI/luiSTMaYSZmGzGFNJgYLD89f48KZDSIIECRimMiDFEkzSaaKZJlCkUWZBUBGmTE167cyfj+Px9/18V8RkkZDSFCTNCSgkQBMYCJfnq7JIFJGRI2RINICTQmAMYlBgOXST67mBkhGTItWUxkbCCIJEhC0JpkiUyaMZsUIpYJRINEhJLC7uxgw0ygxCIQkvf+a/devUYYkkITNGUDIjQUMUkUpBGkIpmGQRMIkM01kJsYpgRRmmEmUyAJhlkWjNKQImYlGr+OuQ0wiTMbCUMyCExGUjSkghihmwCAjKUzEJBQkQEAHz/fgpuNa3+DsyRVMINClLFQXDHdEW65ZKHBLL1lRhZelymZvhkGX/E3vtPfb8Zhv7AavprpU+ZzsR41tdSha7Kla7vItRdxI8sYFxkmjiUM2nHmdTbkgYFdQGyhzOWllyZLameLzK81Dtt9ucPA3JmeXaLooQ1F51By7OxXMlGxLobbaaOwUtgV2ne9qzFQcy0ZZC59ogZT6J1nUq79tfxnPo3Jq2z5bJeTcINEktJgrciefH7r5Thx93ma6XKUjwvlw4u0MaEnAjfKSFacqSwXeLJVvcpzRYWQOuNAu2jSRI1Y6Jc7Cpb2Snt00azSFKy07HCMOpnswFg2nllxV1sbtd8a6AvDa+dK/vi9Na/Yr+TanSHEnaE4RDCEu3L3ezcimC75KbJkC6sOZKd8BHXFm7eBKsqZgD6jiwwXkn12/pi6dPpIrhWTcu1n1LgQKPiAfeBJ8SSSST4FISLSJSYhMZPX19fH119K63rqoivbMZZEnQSCJrNRPTtjMG9S3jWdjEYcjfl5XasimnipKSn42n031w1Zq2ems831adekXKvHK3OWccE7h3AtEqHkmCSPEhL39GiNr8fGxQK9+LyJMQCEi0xmKUwySUK+/D8vw79zL1jX3GdTPHs3a4EAAZxThZh3c9YFcREyisD44Je5s8KpgxIUS9/nz2fB3fi+Pjz0wikgsYZGhkSZIgpIW+fPPH33GQUj7M+/J1XO07MaOC2wr1m62RyG2vw1OGuhsmQ2ae5e51wKlSzaVBwxHIFJRddutsmNWtrJfHSRMlzVlI+YiuLK2RmbudVl9boUuFMU82nWqF9SqWAMAkwTV2ydeSGpBWjj3LGao1Oh9qrrrXJlKrSE8pcFnXYqb6auTSvS7kzcDPIo0hNHI7xN0dNdx5PUsujSjlythzI73DkBBOB6Bt4gN2tTTV81hHbHQhvouGqFXsjiEjBfWbfBRVWYc7pYvLuXxHoVlugaSDbgVJrZr4aeMy6c3jq2W+p49nW1Y2XGVXPunSpMB1XQoUPAUKA8GiYkFmTJMaIZ8+vL38TEqYNoh3nQY4rl1x0t695cLg5+4+IIHFDVWVXbd2DECT2rzB6241GtMoykZldlkjItl1aOTjLICBFmdZ0gLYzm0hcFsPdWbjytEzMz1GO2SSQQSQSQUWaASffcykil6/Pl+Pj18+p8G/mob+qDKC99l0z1Bguj4s/2P22/QrwA9xxRVR8Q0d+l2QSCCRFSWV+l+O1Gvlf3X9fviZxo5YFibsk8APKe5VTJBYwTazqiXZUpxk7LdcBiS11JXdAq7qWPuA/X21qfDbwga5OqB1T+6bUDeEYqGqkI9FW9zQRMIC1rsx476rGra+697dVcW3E9jQxmPr+VYcY17nbz7RmNt3q6rZkptGo/PVY7C2ljpa+yYTmAudxdC7cUEYiyaJ0ymbK3KlXua7ZyKj3oKrq7EgKXtadY3dDN7t1wJEZMkNscmJZfIEGUdynzB6yIpW1Hzs8phOk5mAvb6lVqLr0MbMKQhWKUKwaGDtyhjwp5WOhfuprk+3K0p5gzrdvIhe7m6XREp2SJlWrbQeW0hJs7O7d6yBuwC8Zx9lAnavmczOcztE7qDRhsyheZBWmxKcqZDXllsg10lO+xewQOLHa4lXs6XnKsGMpYLPDqLkiihQps1o3RTYhcDvL2bDM27Ao6TTJbzobaGMWL62ex86MRyRaaePXy78fj69/j38/B1iSJMTQUCaRMZAlGQBLGFESKUoi2syTTMYEkjY2JE0EUNFFqyBQiNMKkmKDJIYlGQqSiZsp+Z2YjA0JgJjAooRgyFBMjYiEojJoyS/f9+eS/z/T789KQwIpEJpJGAzKEmUKUCSTFCGZRgzasp8uUFixlIkBjGjElEhGiFSEhmIyGI0JJGQkxGGUopkf4rlEwiYMphGyRa866YJkkhlgjDEmUbAzFJiQSiUoZCGiShI2O68/CyyrshXCr2HLF3EGb8ad5wcTmVxFd6jmrJmKduDetaKzhuNhNY94CU0CIXmWrZqC6Ry5BslPFZYudZGl1DMu0Jry8zKqlh4VCXuaL5wK0LGxdtjNMUGHE3Zo9ao6azHZAyi0pSOIBCGjMBGun1HKfZmQKHKA/YeIHqO38IkqeCCfGLIqDl/VHUyUbUmESzoq6RtinlCIKLYKCRzGdob8Fpe8VGLfa6V7xvSMgW9Tywobpq3UW2AusaRKau0+7Iw5G4jh/JkN6cz66w4bkM7S5QmispUt+mVzcOzb17lE/FDro/d8xrX32m9WGn63+jfz+Hz9eeevX1XUZRDRkhQiQkZAQplNM713v3efD1vfevz6OUKufTdubpaUyg16sqH5ZWOkhVxl00SQCLGp6S8/OuCptbTrr+qvtFKpMEUBYyhWiAUpRqA4JS8gN5kR32cutoN4HgIPY+xXtGjmk86YGAkgEHxBJIJAI8QSST4Ekk+BI7XlazTklXlXW7KBwJrQmqNUBW0ylRaAAOs10jcZp0ArNdKtXGlGe1O53Uga4w3ddz6GHq15m/PmT69deaWYhCEQUmU8SCT4kEEn1EeQJ9FvVGEXM3LUUl3osMvV8TUB+KvpqTG5zxNCwEZrly8ikMx6IHsVWjBzTI2P7QVLdalPqRsi6WKmPhh5sNDqhwcdTe2qyarGBGDSnxPtHb3aodykp472mo6d3fYD1RnGWDta8xoUqlZmmp1u34VQbMocfa+60ZqR19DsrArYq4Mg7am687atWFgbGflZn32/Dp93zvMvMfCrq5vJNnRhJpyCdmNXlFzGs8hKbyBD9gbsqcEWUK+Wn77muWZS27FnMp283ptbw3YEr7lkzdzaBYHDhT8e/fl5etr2relXNblvfwpMDIAlIxJJoy+nr4+vx3nz+O+vn4u9wkiBl22IuFzcrFldna6FYcEOoAgAcUO7KFAkk4X0Y6W6mXTF+VoFWQL8Ut2jSvpDXltsjXdlXkq4v0ZiHwPV8/oNhP1XSQNnEX92GZxnsAIIPgQCQfEEEggnx8SSSSSCCSxmTu1523Z2lsAMp12bUbO6qdAeHjuEhwelD0S5s2Fk25dbQVVk2hY6TEhR9VLTjtgkRWeSagESnBKfD9uTwne5JuTiDRP8EpvVZW9qt/W+/DaszDISKMspMiSQlqxKySNMlMkgkpKMBS1YihRlMIUzAFM0Rv31yiYpAxRGJSbJkUkjEX+ddCUIKYUqrVWS2rLNw/h1KSqFklOxMBkmQwSYMk22tVatWWUoiKUwopFQGEAMkpmUEJRoTIxJCEUqYiwRHVN31rtdhJgkAkUgxMYmaJpIaEhM+u3YzJIzMpJCYomMtWJJQ0WIiQWIkEQxkYIykUiJpFFJQUFEJ9NygyZBEI2K7txGZGDNJFGRBjCyWDGSRTMiGX5+Pjy9SlBREkMkGSBMJCNCLKTQiYkJhSRkhTZSQFhlJRRpA2aUiQkBpEAiYSEpGPO679/j9Xd7/n+L379Xvz5pp5e7qpaYMyVIYkHRRUKAkkbUKhAIakRgSlghGQYhmIlKJIlFNIEEkZedd4ukbApKRiE/WzaT6+26+Z8kljIIfA0D0MELAwRLAkgIQAFAQhzzGdRXi2ZuVctYFvF1dtHoqYkDfQ1NQpTZDTit5dW0ToEObW8Xmk3eVNMLD6Gbi3WN2gJtacByrZj23qR5TkQllXCqtLttjnCb8m8uB70XbHjO3olyqeC8Zm+PEYt0TbFbe5cW8VM5oNTWxIiT1N+s2Rl5ZHdsI0s1kWlmh/T7shg37X8jnxpjbqtb11NtTo6GWFNVlk6EG4O5l4pTuBQ2Lw4qcP1q9B1J93P6TTogqj5LhuTyEdAhbs+vsWOFtGslVEqGrbq8Um6zYWSXiGt3Ho2TGMJW6mPiBNrVJK5ruevZbhzKMupC61QYo2uNHMhwTXZApnBtBADJh3UBhd5tntrpkPTcvkvAD0hhL15mMDCxi8APPq24zMJ7lOIESmG8RalG3TObQ3twONdcaRgafUryTr4vKi57npBKieK7UagM0IGTadm94Nc63AL2t00BXc89BksGTLpvpkJ1CdXUFBWvTcgzcNtTc57jJQZU1ajnTMFzjnEbvyNX8vnS+FHqMA+q3h4P7BuyGWm8aSmujm0oZ2A8bPtEyy2Rb9Ss8qEzY4uFcHXHdLyZ1d1ZyoFOZnePPsu1lJwhFPDR8iqAqJ8ZoMWq4OrA48phb13GzEkTWo87ttX01cKKzTjLk6+54ro53V2xsSMdgvzVSuXTc5QIS9lJoTFpNQr6+6r3KmnWHzejGXWCrKR+pDFOl0o5lmlkmVm4e04eXu1cDtA6Ml3WN2Fj5bRJeiwpd40dbw9oYLJVPNddPGOmJWyWgkg7TppiRiyrAhv02NSlgyg9fjueqq8wLkzdu9GsrME3pnbei4tu4tOoKdqLC6uY60gKUDImMbXSbZJW4aNZJf3fXsrN1Q3iL5RmsMEsOpkz5btMbl9M6xZma1apcRioaM8d6bm5haPVWXXVnK8dkzToIkqaRi+3E8B7Q++ujhGI3rQTWH4vGKtrEawUJNUPApj6GE3lpUSNdBHuRsVZjcGfGsczGdp6ZZhhpNxZd5byYVdrlsYz1iU/Cy3XRVfAlVLPuvxqSDN5XM7cRUCjFDU21knfarG4QXxmwEuQOHrqXjtZ8g9m+25HjBXy3lvnkjB7TohXffb99nwlZyxD4yLLm0QKLM36ZwM0+wYqk2zg15owZVn2aZEt6X0wZCOENh12uUxVVa25tS7W2+xkd1xSEhynZEXPCgYaD07LdTgKd4PbZdii9qckO7b1hnl26cYXHD0ZvfTHCc+kWd9MfY2SBRND6Ub+g0zjoOFeggCg23OMCo3JmWnmaQDS7HWZqLueObgvTeYDhvaR8Y4MmXfYXuzUce7Od2ROwW8eY5b2Qi7qjgL5DaIxR1kdLtooJ+hoFEBJ1NXuZtC4Bzmy7QVcKDRbrXSU7q3W2YULo/GV0C1qjb9KIPbHQLBf21mI1tDfhrtWG6syZTsQhCXBK69azs54Jou7dYclx5lit671niMQ1W+c0MuJq4VyVGKgyCHpppeE57sETxvt/Ivr/MhmJ/jR+gS7ZcN8xlSl+i6D+V/IHXIrKdD6uFQEfZpiVRI7Hk6YdaElHcUVQKhVQ+tFWN5Z37LfsuXt8FC7eSUCPNVLrGFJdWHjusrBDIhbUxiZRth9f3WeqJrOmnKPO2tuCVcqTmcCyQmIUo6LCO7/IHuVT7Lp0S1X3XG439UGXln7Quub18s42jfWFm81w5R8dEliXSyMhLumzMMWVdjUMXjwtTk907gIwXsO5TyguZzWK3ozl7e5jv03jG+bwQ1AqIlYo8u8TCFcO5KwzekmJ1oS2iOyUpOyoOt+E2QLKkNOshmxZ7rrVkwTTXDpfDQnSIsUsmrAeQPiqScutu9Qi1XwJjx83jkXFhOh14LNnt3SF2YFTSfHNhtDDWirsOgobda9u470zQ+pu3lxyunSS0TJxw8ZWDq2uo5qAUos9nQ7CiG6R2jd721VduTsEkyWheZh65kcUfGEp1eaJArqnDCplWSKwRhWjQdOudhWRuzVnUdQwyp1jLNU2Z02Cu6051cxQbxg2NqUQDcqscYl32Y6BN1Gu65MCvMJ4p69VKFZKbZY3rgvDjLrql6bO8/QAmNarlqQ62ua2u4WVEvMxgtcVImA4Xd4ZKNPQ8ol1t3R4yGdL7U71vXA/YR2rqTbwUwSFp0ZrRE3Mx9kaNzBkGVpGLEBnaplHmtAYobtNdzrhHKOpblV6BbaFEF91To9waMhGG0rUTI2+xzuER/E0TtH8Tx4ZTe9Y6yTG22ScUzlda6f5+Vb3OcVamEtqGrxQXMuLOwqLA+Mmc2cHcoCRjB1zu6rwormnY69tir52MwQNwJ8NC26s2PQU4uaLzJcpHIIaIeVd6lWGslPkL14Je5mXDsZzjHO7XbD30CZYrIP6KtkhtGDyBI8XPjO++vcQCxeWretb3zi1qq8x5kB4BgNwegZ3JuDYAJ0IBXAEgtE/lczjPfu990cEmGqCZGWZhXGpdYpjTORa2WsxXiHzwFAAgCEgZHaZk9NVet+fa87vwGc+fWN4ikUIAoCbARNgJARJhDJKkmkPCaE/E8JsiMko6B0DYHA6HAho7BpEwDkG4NhkZJUk2UTkybkqGiU+GibJ0SpsE2JwneyaE6KTslTJKTh5zEhThcq/zfQu1watjBxAzSCc4pyJKmo3rgG1buhsO2d6Y/hfzJQG2Q2RwgQipamjUdFFu7D+Lt1irMYeabqUt+J7pOx0WCtwZmpsLisD3pWG34KruuTxyZtxGBcAk/aalF9V6+43YHcmn242g7NPNTGyrFwmxhxI2sGvwA91MVwo0Mm129QEeXQ7+e3PsIGg4DteLyeUOH7LIOfDcc3HXVCUtYK5Bcrrnfl4AexyUqN4W1zzmU4uglWblXl5clXMiN1fQj2iVj1TE1OzG6D/Kny+MGuvoe86V5Pp8yqBlnvT8iN78+O3K7LxZ9nt3ciaNVWT4QjMoSXoMTu6aqAsIpCZB6qrw15hJz8+qfGFa5Q+l9Fyob8XeaVOPbXaO17pl5R4WL5VusZWV17AnN3bCy9Jp1L1ishfds0hKmrzmpe6eg03m5mY4P4e5GZy1Tb+xSOeqq989d5m10lXathZXPowxfVDNWNU2tiOWLEzWTOh0yGkb57qsWOGqMKN5wre277NRVZ5yY1dYj4DOG1kQc1okDlWzMBDt1GJ0ukOHDsi3OuaQtZiPlqUrajl7fYKuXzaMtS97pLieIdRD6Hqi3kKg3ljq+IrO6n232L2Sl0E9CH2zsFduK6dbkh2UW9ycK7SahrWRmdyLdZ3DpxSIdMTr2R4DAcFdd2Ru2hN7C8n5RouWgsofM6bMswsVGPc/aC7+JbPOPu4cMmXMXF7fGGarpR5GEqBw3lewMm8tb3y7qlfdS++CS8w4LQ+tuY+fLMuinsJ++SRlW0rnzsmeYoTqZ6LkZaV0TIdVpOKVcpQ9r3NjPQdYydcubbsaJXK8KVNMBH1VXhsNzdYznSPNpGsRmtKVpoI6GKLtShKfaccxTDXCnrmRCdaBwdL4nZhmcsVGdfKVLW6LfHoKTPU861rzdCZOI6joTy1JnGTEsYHC9zas9VqkRFOZoBvnylzVNQOZN12R2Ugmy/BsCFLW61bu1u0b8Hp6Vr7Bord4UBoO0/KX13alg+LzsPbynKpzblclL0xVbknbdi9w0KssKOOsbWDLutqPFmrsJ4injjw1fPKe0N3YqgYysqyMeU4J5LlcvqCRdJnbaBk2TNd3TqBG06lWdddl6TOK0GZWboyI3mRnFr4KtZ3eVWMkQuscGc/F5F6Dtq1M1dCvcRg2JDJ0rhwmcNROipwVxDcxXvW6zhR5qCJvONvcgd9usvZyWsTdJpxQoHXQgwwitdvnubN2rDj0wmWL5OHcJOZ6lmObquLb4IhNXJBDvrrJVVnDU7BrZKp5uXzCZVXUoXjq4M5jLFk6sgoSH2RHr3jtTs2PeqXvc7VXWRMt7YOkzSzbavNwsAOG960b63Fxtzb6X1tOx4ZQOHeHPd0c1su6uBBsaqmtY9+Wc7WHGYyEPkMu7v2fLKvftvM9XCw1JOTTgg4lFsTMs4FZVrMVxW91+qq8E8ogm2xsHZ26jnIziHWXoy9wWgRiRN4qgzzJcM0ajwACf25RP5kH9YHiKBuPb9rxG1Ne1yV5rbWsF8+SVmxkbuG3diggX+4KBrDDR1GMxDrMWhhJ9NS2aK7jePiObicvEkjeqlna0KuMUn/HaFdhJvIER1lJJTVD9FNSrfpY1HN7cEwe/APb2je6nTXSxUtEfVFhtm/F/WtqRcxLAxltAJ/ABNag6QAJoYZcQqwpOGaH9e3prcd66QNAblfkJlHZYYyo0yWzKqYAnm8ul8OI6p1S46mZy6GqauZumluPVSWyWwDoynev2bsObQHStcKukYdid0uYqaaizYwU5DTtcnQIpXoxi7na9Im6R19wkp05S3enZwHnHWyS6OdaRYVQ41ZqaryKP8kC60KgutFOrLGl+mnsmF46yvj9qvhPWbO94zA+0qWn7VbxUinordh4PKWr1xh0MccGEVMpJWT9d0aYY3Fg+hRLP3z1H1A4KD7ElvG4NVTemsdcc52zjWtiTBPA9JTk2J4YJtyBRR1z6Fkm+pP5hIJw6FpxK6oXckmDRDocLVz84XQ3ezs/V7s15V2hS039KyumiCNi0pZlCUir+7euXed7CJwzoj23O1WO3oFd5zzb6toJ314scGEGUFxD2Ou7DDnGTNUoELDTg2nO37rQ+7Z7nXXCvKpeV99ow2HfhxG7cgZfuDNoaM5rM2uxHiqs7swbevGq2NxHnlHuVZTBzMoZrYw7hwLwA9V1cei1SMGSuVVL0YKFGtkyknl0X2nRYyS5dS8xd2f0xysqMcEuKtcl9D8JeRbMqOlQg5XY/qB7LvxqxKbZ4eotd1TRDsurV4ZrZg+NWXUvCvDe99tECWAgTBwCMaZV3mX1AgLDU5DNB3irasNV1AK3pu36hnYYCdEEHB3+zXw4tLOS+6iTMNDH9rwWkhYhdiA+Y0w66+xic813UGY9bIow7xOq9GR/V3A/cB5/VdB93ef25V7MjCAovNkUV5sAV4gksVC6MUxMJtrRnUMS9ttrGTYHfa33gRAcORVXYHJNkwf2TJP6JknBSekomE63J2G44JgmSUnaOvTYT+g7E/tCp4TwnKfCWQaJ2mBGLhDkcCvANA7gwf2EKAc4x4DYcBjmg9lAdYZipAUEISeKjnT6zq5RWVEYgkANbSxbVLnRQSSB1W3Oc+8bcY4FQGwoyRYaYCiIUNkjGQzQCAMEpmiUhAxSZBCiaTSEomGEv965ljEiGFEyaFkqQNBRJkIJMgmkmEqDJiaYyIJgpAlEQssKMmBmiCAkkKigsmSZIywMBqEklzsHsGKsHcGgYCy2lbq35+PiURJBjGihmTREZjEpjIQzRCgyyNGCkZJGIzIMYkNDAzGMIiNiioaVGZNJiRlmiwikmMEKGQDESlAIyGBpMhJIgmVkyZKCAMyTPul19hJvULwUy45I2Ve5txBuoy0XcRAouqwXdX0VmpM2jNACFOtGqd3bDV1dcxE3Hge7JVbrNxSk25zlTqJw3oih7dwKS1jsG3lTjHUm+LyyEv3ylxBvObe6/tX2dLj1iDVJMRu4a1p4Ta0h3Byza1qmXxdDRFFXVmVEdWDO6sNk9DYoUMLofyXU6PJuIrFKOXL+p2o7TNhys99GIRbrHp3gbF5fQbqwVzPb05vtTy2NiKN47l22Kg2N01sXdY0b1ALmd6mFnK3RQubWhPdpjclK+3d4UEeZzWjxOWtUkrg11L2pmz1SrQfm6EY6SdjcoJ3h50q0SPq9XCbh8xwrNZCchgQZo7d3WNcTGleIoq26A6C3wAmsjzpTLN6GLHpOebymN5Y1owHKgDp6iLF13b25m8qew5XNQG6BNlHpssHMVepHrGH90Px+QJIJPiyho0367sMCJKfP39P1+Pj3+vv53DS89WwmqlLQNE/pvN8BSmHc2c2u9YoE8ECI2fEl9VXMYG5QTJpDWgw4tJ/CYDsdLKI3eDr4+gthMkhaOCkOu3O1Rd0snUXOfVClq1CHxBJIIJPj4kHQxEpCkpkiQPl558/HvLYkM1XU9soVxfG6AAjivfGdNvKFPGqIAB3Fo8NzIWXmyURyxmtnSt6VShrEa3TSkDsuUMkkmw171eQAqgAKoAUGkCYpjGZCIZKbAJPjlpkgEg95i9axYLNLhGZMrWbqtGmj1BvVI6Wr+uZl5ec2PjLOAChp9bJxZambKCfgB68t2NUzTD8O4deri7x90Tzno5PTimSZoi1BdtrVfmaCyUk8tVSlb231QskmVpWnAuUy+YeEZAjFVFN27dhO7t4+e6AnU2TapiZxHgPUbAqemG8Oa+q1cvcV9rsHUyoo+MasXtm9g6U87ShSBq1GKxjTzpHq9wpphbg/NRb+xH5DSyZ8vhcEarSS3ddu7pH0y5j06lOlWvgg3Km/RqZ0vSSdQ14w7O1StFvoGBGa/hzBFIGEQJIBKEhKJmsurXktmoV6k1mwtSXfS5zDRQvtwk+MNhhRmq8ILTPWjQCNOqTWfHdN6gtuCR5aHgKdxvhSC2yqGG1kHB5uKCzGBmusViC2MpFGyxQ2yT4+IJhSJUhEEp+Ovh83r6fPnz7+ib5xxaqxEEA6PV1l2c5UswENYlp9AB4eFSXIhFXN7OmmgyOfSrqszAKfsITywJQgvn0RxPPAD1tC5rx9RxaYzM7jwv5/H7wA9i2d8blQPBXZlhlwWbPgB5weex2n9UunLExhBiLaRdXnc9ernfab9W6HXbN7CumEaIOFbeixyvOOyLBMOufdC9K77ey+K9GfqlaHTlxN5Qg2WKAvba3J7ayWepyURWBhy+kuY95ezTQsHhYkE13URElct54bkxLLsisq67NDaYAmw21SnQmW1KIV8xLfc1t5QoLOXCUTFcRFOaVCco0bAJh2nxvcedadb689Qd2NUDrpTRyzhOXVhEMgnsC4dCcl70t0UlvTJbXoc00dMhxNnz5cEycs8qWMbtArIpVlhVBNQeOsFzsFrstFingyGgRsjZ+pDUN+y9+XXdnSL3UzjUGJgsugX7QKFG4QbKA3D9fwXzvjvnrvt+gXPdrDWAdxuiraPUfoa1mPYQcll67si5BcKQti8Pz3wPgSfDxJJJAJJiaYIgJJiiEg2JSUmAKJMoSTIUBFJjSkwwDL8duoksTJQsaaLNJBctclEyMwTRmUUmVAkgUiQpAkkmKmBMAwxEQFfU4yaQJoRKf2uL8/Ftu8yEJssMJSiCjIimW1gmQmSiRIGGEqCRWBlBSjAygiFFiJEZCgIyUI2NEWrMjMYiQmQNhBAJaPjuGRNEKUgEpCUkSWrLKZoUhKsVaWrkmxMZlRBL3ecYx31p5mj8Z34jF+ZEezOsXttvhe7WYQ9b1mP15ds0Va32bVKBBCtaezapiQDHQ2FMMgF0qBEI3dY3KrzFKriwRx6qx66GGoeypIaR4LrqEoUOx9pj8RCpuKmpVB2JqYUNZmpyWK2a3VeHla0JXuIte3d0KQC7sg4JFrWbVt3qdZRexEYw70O5WrKYiCYdcG6tKeGQvjVjhfPa89rS8YdVtuFoxDQq4+4GdHQcqyxWVcFoGgZfKU46GBqW3aoOdrG1euGFVrzNy/DwH6Tqw1ai2Q6LC5OYpmCGeFEPChjbzV7CH6RCi7RIYNWrCJtSkChQGIK8tRxNOxKtm9Jj04yBN0UbF5PY4qynunfbocLTSvaHveEsCsW6Y9Ft5Yytb11TWEypBftRjGnGTHlIPduE7awG7U2xNiis0t1b3YmwodUCADhRNEAIwyqINmDsyj0hSGUE/pJEqVPjdVbDzrmDMyM4zUQpDIhK2DczMLtO04oHUtrYmAmhQOzyu23tOkBBYVTYdDwI2/C6lIqhdSsWLdmizTtMzaNZhbgIMVGMsvcxmxbTWKnlgJm7RRmqIEobmB7RI9rvC1iMFZK0NiA5rky6MNoASQ1l4dGoWLWqzivMCOQ4VAxQc1GNlXW3crLW+NiVMagm1XgB6nsEOyK6jRMvLNXYWxt0tNS8Vwg7kAvTPBy1h96q9JbPqWxO4G2NSe0b973nZQYeMygKN0aeXlVCMoJKLtvrWNAg5542roXQoMheTZY13T5W622KVWRGfOMo3SRG02JDLAcVKktSiEG4V73vepq8xYasSwcg3WFKZrW7QhDtDR5iIaVI/Z4+SQiPrwt7KmLzV7VNgbOxjGxZqbXrvz80A4Bg6BRCA3GC5BsDQB9BgDkHbnX5t98zrn99znfeCIgATRvfoDNcOMcoVy2Z8EBNhEAIOQoaEgKIS/pi4Pe840GtVkfUguzzbAqlwH33pOa8wAB17YFyAwQ7JvgE+k+k6J6T0fb9x7HHPc2vaNutbeqGvb9eW4uCiGfhCEFDMBeIinG4UIQYiwAgwIPyDj3Lx3u9e+iGOQ4QFCAsBDgBgiVdzfHfzWdfOu+fdX3zrOd7TfdZ737Nj3JmVqsvfnun53NY1vece6uOrzkZ9EtnDcznkGOVXe1rlHjaO+d67cxnrTmr10848d728e7VeV5fQcBWl33zG/XrFSuJxjC7bit2GxW55nser2Mdc8322e995PubvvhrMaeyIPiM+8Mv0dadz7OcPG94gbJO6yWOyFqt53WMc1zu++XnlXfsNrb9r2eNvZmHHG6AmgEwAgQgJgEoS/N5rGSfvJPb/KWrZ8pila2IxajYTUVFrFUWxYNGsaiqLWNG2xqQirFY1RWIouu/Otqt9fmdUUqUaBQGgRU7BQHayCAyEm3vGfREBkJHAgg0fFEBqMjJA+IoD4HYIgPCqA5VQHCCCYIglBEP5EQi2SRVCG1KiI3VER33uj6AKhoiABI21rdatt1qulayZNZSyBoslL/G7SUgxLuusqWzZuuxu21kGu7u67FGbuoua7uDu7Q7ukw52c4Yxc1xkxIrlqMUXWyuWt1platG3NVy1EWoq0bbNLUqubdMVzg2qhFkrlBxtbl07sdNLWs51SSXOgc4iYgJYCCEO7h3d8792tVlrVZa1W/e0CqO6AIh4gCIcvqiA696azf5s2dNN3kVVywFAoAkWSRkJGQI1n6bttFgd3SJ3a7SIgk7uwbSRc4Khk1DIEqJACxucTu6Rcud783jYK8VcRNd3GlMg7uGyd3ZLYEpFIpmbcPJ9zbV/sttX93+jC/l0kTRJgLldlMmiDm5RGUUgRKHdXAXTdGiJlgyyJDAmUobCDM0hkuu7nJmUSiAYuPkQ9LagkaqJBPYh7EjuAppQQIzIovAIIlIoD+rgl021Wv3lqv9NtrpbVP6ZJMyFW2LVSqq3vfz+bYTYlNydEwQ/obEwTslJkme8E9JncknhJNzonKIylJuSmIbiYJSVPidROyWcCcof4TlDhKn+CcE2EJxJ0TBPhNiVMm5Kn3kchSUlQpHBNk2TRPskwYIeJpEfSfDkG4OgoAcA0DQb57OMbc76SG/e+Nnz3Ple1v5a9Ev7d6u553E8d+p2YMdbTn+FV/KqqqqFpwAg5eNqakftcy8GPCiA2M2vJIS4iA1eWl6MuBEBxhPUQS4raUb3Fv7Ea9a5NaywltpVA2xx+1V/Gqr+/6a6Yc8VGXNvdt7X42XS7SFMMDGMLT8FO2tM/5EiH7E+1q1Y3oUEhUaM345kkkknP7+fQ2dofkpIEXihNqa/hVSTegwkAtOkJVNFBHRV0sVhfza1bui3murg27ZXp2vVVlvZJerxsFqGySrUMiQqpnb87rqq6qqpNJ3oGnf7PyIfiCV5IfZ3fPm23/kz3EAcz5LWpIROGqngqBKGFyi172mNt/1xVW62q9us2vb+XXJzNyEUpoJCHXwVQsSYuY1csv8MZM1iwtxZijurVkf2byZKtKtOva1DhTarMkVYqsIoMIiwEsKSKlgUkSyWSRYiUW2t+LbbYgbu3dddy6F3WXU6467OuupcoU3Y7XWdm67u52crk6dnLndrrrnXOurnXdibnSUXbo3Ll2u7nOGWdDG7clc6i5C7rsy67dLpyBG7lc7qTddzkuk3V9X+3+/1/r3a1WWr96mtoQIUQbUtlVggTBapmwElmmpNFEsWUDGWJm0JJJGJPDPSPAO13I3WtfyHvgHwGKl8gGQyUDN9W6/OXBb4OIySS04uAMEpKhUnHrWN/N/Sc8J2TCChMEwSkpNzWSdEsHs3TgnOR2TaROCSbFCUlJWiUnhNJOCT3gHgGvS3Xd+ttYxvjvznvHFq5XcHfIDgGBMBSfOu+t49EzBwTBMibk+lJJgn4lJ11hME3Q54IZJknaO8Rue1NyOSwoDmErWX0V9zcs2O2aiHOXzbdQe/Zbp+Q6J4fg5lJpMAomCGFWgCDQwLA+RMY3xOOE8wh0kAchOe4iUQpMkwJSZST0mgomImSEyOcIZkg2JdIjJKlASAEICAOAkpze/Lw99agQ8Ucb8FMREe1JPCUTBKCpRP3O0L793xhbWGNtm3wmxJODIm8SG9JoLDJMCaEwJ7EdJZEbJSSieJrIh8J23EpNyZJwek3k0TROBKRHh9ppNkRoJSH1D0myb4Tj6do9wDCFEKEkEEtTjOdPgtxV8tk0q2Fro+b/G0xnc9EySk713omCaJySk424NJuTCaPSZEqU7N8JlKcHhOyUmRNGCYQMJSUKTlMk8EAHfaPeSAJudYYkqw52Cpes98du240Mh68W1hqFKAqDZHRj2saXvD0ewruDpwg6AmhBglJJ4+iPCUnhPn38+2PNjAlJlOZwG3xMCURSbiUlSTjgm4nSCk3Rukm5IdibJ23JuJSbpgTBnWfpyJ3j8+Zv3Hy/ntxAk/liE7JQ/zqCHKejRMkqHBP6DQZMEwSk+CU0TJKhhKSpgmEqFJtCf5WIg6sTJsgOAMg3YA3B+jSjYXMFGRVEoGIivEBB6iNRVLxRUkSQZMUG/PBMwkOSUk2pvWxP6JsnI2D4N9gcog44sCtkYDkB0PANWY8vtvz+76WwuCdLYHqByK+xES4MfbD4TdMIioepshomE6SplDRMRHJEZQqMmUyZJSI2mVPqAIhcHQPDQNDWIe2ROIIB4xFaiH5BVO4qH8YC3ggEiDoGCNRC8VMRQHbcZ+fboqX6D9cW1QoCfSfPp+Fsycbc/k6tWxzsiALgYCEBpNEwmiUmCYJSYE/slTJOSYnhZ4TdNwwJsTRNEqZTRMpkk7/0Xj74Q2TwlTRYck+JGEEYD4DBXAMVBsJEE7HcYN9frPeN3awMH1KFaBsqKGh3oG4OAg6CEybkymCYJwTMDRLJEnZNjJ+J7NvfdyD4TRGJ8om5MyRH4mgHcAdrbW2xx1zx5151377E3RsDnHGtkAQgDjecz33fEYrrcSn22TQXiax7rphF6ECBlB3gO9sA3QEG6+8UyJRFWo1Gic1RjRzkGrkbc3TGKxyiwbbnLcrnK5cA5tjbmucndQbmjaio5a5c1BRu7qE3M7rpv43+a2Ko20RZCxH92AYS7kQTUwzatoABTNohIiRMBDu7ud0hJjEmnXXIQsBc066xQQQW7riKbu5YnOjMmaJJExREFKTI1gtFoqxtjUUFRRsaNBslY2NWIjWg2IybFhJNjY0WNixRRBGxMxgENEQYSSUoMWlhiUgSTYiQmaDJGIksImQpDERoSyKCSURaSWQb4+Pn3r0qjFUWNsVFkqIorFowaKIsbRoxpNoqisURtFGk0RSVGo2I1GI2atTem0VFjFvinINqByDvd6vm371Tb8nYA7g/gNgfoNT+OyJpG4n0Sk7JMFJomG/eA+b3+zH70ZHoNtlDWyAAb3+dfq+57itbc0aqtUCfqCIH6iq1FGQQ5B2AHYGZ/wsCN7CJ38680kI5sgk3oO6g/ygC7x7zQgLmKvQCdDBCjvn0GyonMAB1ETH0V4BsKhzCgfoO4nv6DHQNvMeAMq2/zWfduueevvn3cHYAHuk/EDP2yIZJSekoT8Tfl3Yh9sQlRBK2a+8kylJSda433z+vnb1V6fvs2gBUBIzATuh0J4j2tmZyEI8CAVJUom9J8ohmUnSVEeKhrfS54Ng4fsYyxwNhgecnm8oEUBNlRRATIIFgb8CFhPTfmu9ayPuuAOsgrwA1RyZ4u2fsvvHvvvV+Y6onBDswnpOyaJgmCfCUOhN90p0YJ5t33Vtu2/NucR+RR2xnXG3ggHXGctxAnKem+/chLYtaSG031Vzu4ML4DICbCTtHIcom6CDTt19x37sNsx32JxKLm8qsOpQEkgEkplVJQgJvzeyGA5x5GeZsdd+MjdHdOJKxLcsBECAUSQRMqsO40RC6EkJrdTwXnI3nkNXjKiJlQEKgWm8wd1krvAAKgxAEQip4Njeu9d9ZWo+TGNkqBsZq7jPp353dfVjc7XOTvghUTxREHkBBCEkEzznHcGQa4odIC1eN7nUalCQt3JEO8bu2M0fYEjYWBjrzB2S7RCzGyBmyJGVgbe8NR8rIf6E0CwnI5tYFnEM+caqx1i9i82z1vo1nIZz7h+xhy5IRCXD6sfukxPKxEXl83cTirXACNQCgIUCBBHN8tyM06DbG4TMZaVngKUkMDCxK0NYwlBgW0gY3votJ6/mW+tH92BhCwxZJLRIfOs2VVbxE9tSA/YIJeCfqCLUUG8JJEW8UH+MEQKig2gi3gqSCgPvyniIoDxFVHEFNRVHEcZpUxEPWIhmCyILaKSKSB8gNogtoiqSCvsUGoql4Ih3BC2KBFkEMMUKgIGefpH0S9fZ5z59xz+3pH8Lqruj+AbYDe3lUyTKsAhTOuZ/L53Xda3z3t2nHNnyJgboAiErdhjja096NbW251vmkYgW3PeiHc8geiUTpwOIrKuRlskOOKukB2NW42FcY47bFmw7+6929va5qKD+QER/IokgOhyqlcRALxBJFUCQRHhIJYRikG9gLRBbCSeVET2vOYSDEhtY3pA4klhJoLAG0RkUKB/Aiil7IItyIJYFEOAdrZ8Oaze/fXzf3355+fnuhURD0IgiA9MVERyigNhIKLuiHq7Wr92/vVFouU0Uxsmo1FW+L8rTJMzJEhQjIiGkZIEtX/Hatf8W2syt5qq7VqvLkGBSjEAWtWrUZCM0KqVYQwgpJJcq0mxKUn2OCWSKabfmxuwmA1IFMGFAxX6A0DAE/AK18Nvz4gAP8YCoDbMkm/51CtbhyDoG36PveAETWttX9vfH3QK8BfBrba9njI0aAYD+t8jU8Qk7rnYVIQOq6sD3jXMNy8uTqubl/BvZUv8hLvdnz3bfbfebh3mm93YFAdlfM2RQHQouK6o3VJ4rrahgDUQtiWPk4STgSgEs4lWSlBaSKlxrmm3dIdYbquQUBlwt1QVG4Agyu53eq3ve12hBBx67cnBgQQfSubHqDbawIgzuuBXtpEQfQEsRZGyFkCrCQbc5JBNEQT5JEHMSCZIkj8veLxzqlqykWFLaTak1VqVom1lptqjWiJbbbMo21pS2g2uZB1nJwy33u6hKnzXF8REQAJniDd1cgIgASffHD5sCIbazMgiHe22ZIiJ1jKktD32RqyoiNwioiPVsc3JWrCooa/XymUJJcYgRDHkxAiFWBELjECIXEdGYEQ51tKe3SAIhGIAiEMYsigN6mcWzis528xVrd0RaZrKMfzn8lYOQpCuAoFEkEkeKAwOAYnLioORqhyDVDIiYCCMBie8g2BQGzXdJfnW/nuTHO+Wz7AdSTGKvW/F58GsSwboo9QAUP8YgCXgMt+V/f1/V+zdsYtvRePd3V0wW+NNpoZpvRUIvcKgnyNlUUBzPflWEXKpK4xlxOxtrR1x8uigOiIoD1tSKA0QVAfNce3RQG2KRQHO1CKA3ru9XRQHcRBiKA+Wz150INcKoD5JvBywGqoYKpReKZAOx4cEBCgIAjAbWX2NBWw0QycCBsnHvylIL3E0ApQZOKBa9ogCAJiHXmFVPbbfz3zhp+JJ4SVCPhKI23pOR83Ytv4x8ue/fnec8TfHfm6P4Tcp0lMntGwpMA4Dne8rGygD/GKn5EAT8YC1AEGQWRRJEHXdAq2gg3iIm0QVPYqN4oASIJtBETMdGLWNoCq66pRU+RVTeMhmPcQALQFOT0oUtFB3iHMRVqCAH7wXAclKGYqBiCIEiL39gI7Hz7sYtcqdXMfnPeL4IIEgKAAHvzbq2vqIfmlTwHiUmyEJSYlk8JSKljFYS6+aZNUrNtlZqWWlm2vhoEtekQ52BRDjXN+cP1rRCyKPHSqA0qIjAQRCJ7MmH33nMzXtqtx3jZ2sloCD1BAA8ebfY57mva973n4gtAgCBAE0+MkyFkjemEOJBD1bZWTnjn3rxjO+7q6J/mSd0n2eWahr7nkUsgqFECZjRVd5fbE7ZSQVURm5NUzWrTF8xM2MHH69CaEfdVChbUpsYdEEduXzHVMGIJQOY73jKxRO9rEhJS22OaxdirG2LKeDSlcyNZaun4FGWIqxFSyGymaGtaITW9FTy0mwDZDvdo5DKjeDp07LiENpa26zbx7tr25DUyssNWKNDORrY3lMazgzuX61BWe1l/CVsXa0hLpAyzp/d1r6AB3h7wOKBN3dmrxrtdyzRh/BhYIFLrfdDkCzyCYxscenKt2LNySyawrr2M0M9oYuCCDNzObzbWLJuKruKsyn1OskZm1aSqdURpVwIxZbD71tuDnWbyMYvaXlXq8LFnW50D5xz8T8FFrVKIH4gCIQFA6LcZ1Oe+3nHetjwMTFSHluczjGjmd+AiDPy9ZoNTvNTuYt3i4rYDro26yKv5E/UQGogsgAmzkazqkXEVU/xZzJSBuT5j7kxIgUg45y32YkcWDmpAtkkyqRHBOcs3qIg/nlrimoAhtFZBFqBlFAggWirLU0QCyjBCCquwNEB+CFDiAAl4KjcHevLIzrXWL/n3vbz866+fLAAiHhBUUdonUBUPpEOEFTXNAh6DADeKIvnlKInYgEB0c92BzqhAHggicwBAx135zgBxret6PHAY77Nbd321m2qBBEHPW17yhtw927ReJ8TSyKMIor+QRQKZIKoMYKAZ81+fOmzDqxx+WLdTx82xZQIAnG99Giazf1Tn4gGiiaQMAvEHe3q10Bgcs63+b2MEgIsQJ5xOMWtyxdG5Bz4SSMSBGbqljI1CDBJAyUA70SBrb4y+ATvO9cT28gkkkkkkgj1erXjoDR8ZKCebCC65zpIJJJBJJIkJ5v1VVVVRRRVSUZu2AFdC6xshQ02Q2uRu/A1AxRGczkMQiEkkoQQSShBBJIJ7mtbhRwPE7pImZlqgSKL1INMS9SthGAzT6Qkh8Y5nWmbDY2mgiBF/6/4/z/yf/T/9Ad/4D6+n8CEZIEhIsSSfoproRBr7NvM75yelWuvEPzX7W5FQG93O+AtA3zRf6KOP0cZrpyTwhqOptyNssRD/RiYSQu1e8BR2F/iQkkMAAmX8wAmKrMIri793sAKdlExjE2u9g7SQfibkoTIhMCWoj7hoJ1h7R+le4dc8EQbHwkEzT3AioiOpSqA7Awdtb7e4vMQRCbLXOHneHyzFnntMEgnWMFOcJIASXAVMKio+lA8uWyUlQvmAQBeaWfZ7e+b37nfb4kJWWA75BZwLGn7IHsZxxdDZTw4gnn/Nto67Ex7wIJhH6ngIhwQxN5+Gnv5vLKFo+zXvFkS297dXp+XoNuBsF4LVLJ1s+eXR+pzfPuB34TrsyZJohQgBRyHAJFqAiBAI1yM63y9fb533qF963UJwMTb3m3Bfj33V8uY3IhUbRqGtePjt5kRzXFe4+sZXGGPMDqjeyN4EQqXj69tGeKdoh1nG3OsgW6ABEKE2Ysgu/GbDz1Di20RQdTMA69E1zdLdGrDVQkjRfq8sZlRzvawHMU5WICu/fjtLhtmigFEYJztyFrpBvEKjI1F6TImbHe9e83sobRce0GL664wdzBEnnNgHuzk8qn775tPeMLKWd486wZXxjCqa8/WA9jNt83VQOEZ3LftQ7/KPIeS+055RELwVUe6KBACKlQPAiPHNBhi+wAE5OqA2nzdPlqPIhTiUQ6jx8pt6UGE2pTUqPvNAvflA5hvC+9X5AURriBFDq1rdUD5HAqsNwKBoh/u4/h/r/b/aaSSEPHdsMKVJBKMTERJLUAf1wKKIB51XpBEKtSoKNoIn6iqA/LeNgVBt8aeEYiAVFDQEXJAeOKDm1ByEX+EOc0heO0wAQ/b9Ud71nmnyGPEARCjPmLGrUbwN/2o6heAiTusV0J7nJmrWtYLjHN5rZft8sWvQLjVLOqFxbuWBhgIHKnFC2hIThBkcWS0N/pj0zzQskkk+JH4RZAHbGDlUUwQxD8VIKI2FG+hse1zHe45vfO+ZBikZk8ybGExisVq+vdsEfM2AtQUXRQGB6ECMRmbaAXwoGiI11iS/WoIAiIaJKkWRcA7hjmh29ryEmmS9zZBuQUgtpqVeSFvW51bWfeNt+ffPPfPfboAiENgSPcPQkEwiCYPK1v7lxVsvXzLBWa5+bZ4S9bwIhvjGWbM/dZd1SbYRupvTq5suMRM3eBEPvRmrtW1fjm4Wv3fFg5c06m0Xa1JUPDejzqiTUNptdAEQrMkLR2xQFeNHUPfO1LB7DK80SQkIkIvEnVHNyi+9HN0ARCh7qpKmJZiv1d1xW1ixxi32ts4Yq3gvd4szS07q2n6t8b6dfcGt8YusO/2tUvUCIY8gTmikYcS7Lwm6UyTegqAavQVrKAIhYqG3VO88nuit6olqGQzDeJUK1xq7JfSKA0dPvVhJDWxR5wBQVDhgd++9XDvwcYuVDzBR3JOuAruXmYmr0GbIh+/Pw76q/n97+PUikXbuQOXAhJIWAqmlUyV7JdrVEgJvvks2tQqMCiBECcOu2AHKAYIFXdDHtjV7Ht9He+U+973h73h73h73Qq+973h73h73h73R12b3ujvejveju+jnId27z3e9He9G+8HOzMQ/fd4Oc4Na4N75dVMxz3PcyOa0Ob2O3VTPe+7jmeaGubG9Zxd1XOe773hnPhrQzi7qp9Xr9j2djWgxzi6qt79z3ce9ryW+9Nh4j079fE8B2l365ncbRBBzHWAA5jcb1auELo1G+OasHkNStrWTEXCEG+Gkdotu9YtcGoOt9gBswF4AGhKBwSklJUqFJKSkK/TmaGbInvWPNMMfeNvGxPeYToySCYEst9ue+A5lBcox2OEavciXBCSQ/FmZyQG67QoW+STgY078jRz2tO6XfWRec5zHb33eu+96OM3nKCBSA6xn0lBnulzw7jNs/OZQIgATq5tkSQVlsJMd1zbzjp3uvoAdB5vYQPODVgB71enQIgBICDpCREFCwCLBq8Y7Wee17vfaVAAiG6qM81AyUXEBnWN7eRdBkR7xtgHb0svm5ugAm+YZ2xHZPhPH3zIATKbAcYRmAAAQA+YGNWL2zDZHfbXPdF2m6xoNzcCeic5wDvx0bzzrsC+ubduN9++fK6Utyj5aRGuRMe620HWxDH+UJG7vGsvEIMVrm+ezm5+RNgCUklLJMPlevl9wVtw0pkIM8xkARXbX7V86Nm5zODzhOp0lTcC02VQJa+jWt/NYA/fqgTlAk82Nnsczj6jUqnEbhPvm1E6ukEbZ+BUJb5xiwbM7qEaISUxK9EIu3JjgaXPxcZT5S1t1PcsU7J0TzLin1Tql/mHVNtvm+j7tieLtR8qlTNfde5doRgJomXv3Duvted7Zb78ZdY41pw6Oct/OA1cyDDvVFQqGgfeb6MGgYekMB3TsiMEQ6IDBgumCghhzHJgS4RRifMKIlfX1lgSpUNO5bTyLvM8Ptrpd6cBAgQDUxL1c5+fPn75+/fvXcmvkiMoFgWBLAR+oQCRVsedJt51s7cD0O1vbSTnjg7Hu6j5jqOtvMxE0KQ5wT74ly9r4Svl/WwAESwEdeccBFC743ruu99rfvezsSEI6Nb7ukg3Ju+vvudSHenWQng9ZxrieQBAgHQFgBG29hEEP6QjZXMom8XydvbNjmxeMFdAs8845xztn3jqDb05zyGJpMCsRREIggMUVVYKqMBZFSKoDEARCOINKkrs8xSnFtbc8pvqYnvtL1xjfrXITS+cCLnWdnEroZrPIuZJsgKBrQ2FJ1DPnwSl4QUG8jjNg3SNWwgwPP4YUyxtnU9FvrIG2bqkti+5XMA8zWO7dRyb1oCwhDn0dq46PJ7eDxD3hVX8P9cf2/l5XXh8PtSBUEqNQagVKoqwpUQZigBX583LC1a4fPP8vzbkKx9lwEOg2+84FUOt9Vv+2Ct+NtnF6xOBJHvjfP7HlvZai9u0O/2uOyLBCCgQFgMERNurVl6vW29GUFL9nmS8Bv1YHvzAZ6E5yCFAwGVRUOz2jnVc1nSn2Eh93etMJdbtktASSAhSdem6QG5X1PE37fO9772tIFw4zE91WqvtoH7Wp2M5Ty2uOBAE6L8q+tnvj0122WCbQAoN5d0CBGPshFQRN6RG6Uh3vPmMojolA87Yk1ycWFBva3e1tufN/ePOfe/fYIIPW74ICIbg7WEQHbXufTrfy1x9EDVW5EUpgCd4wTSAbs33vfYkFe76bta4CfqmwNzrYCMLzG74I3Xm6q/46C/fVRy2wiBEOeMqIHzuueLHNmcooDKwcc69+Xt7vV5bNILelrnc/v9ajf3lQd71ggQAI8OPgd1S+FVaBEExX9pvj91fBq/uezurXXnnnPuc8xYkAhQKxZcOz/Dk27N+V/XnzebONIEQAJw/fPXADlJ2sIBTeaRQRSAKQIgASsX9zHHdVweH2MVjnMk5FQHr533v2Aq/uH/3+dlRU5H13k5lBRVSMqVJZAG6oIfEfJ1ySs5znZFAbZ8vPHP2maEQeK395sZ2zu78Wycz8hnpFAfzget8cnm3XROe/LwFTOPBy64HhedZzu8hHAej+yHCVIATe1DesxwqAK2o2eoYBl9ViGG1X5LliG0sqXqBnBixeHAmG5IlsigowN4DXPCRI20guVQIzoE2tzcYq8Z13vvX0Jji2Be+VbDwrWMkUZ9pBD57jwSbHvIg+2tfO/cHkTsHrFAr3caBcCGtqEPALooYRxOK7tjrrvW/fnHfXXXfvvSqA66VVdgfQd6ALAKIeatzydeBTcRvQnlE13gI1UibEsId94JtuTZIoc6ZlJC2SJUikR9sIIRsswCIgCy6BghSsRq61QGQ9KsAaWb8ttkkO21ZgJQIgATqDXdDc5406TtxHEJHDYHYNDJJJhPLNgkN3dbinW0TWPMgsyYyoRp8gSkQCkUDsnHKD0zq+cNrqBcY7rCsteq+pvW1QSSdLoNprI0eIOzMPt4RUQdLQyBQY09rvDwFiHucqFxmx15tA9BERErHH5qmllFfl68/Xe/vq/eMRfHbduvrzXm5ciB3cCxed0cOxu8u8DOXJLi1rSR6RTK9xAkRlIBgHSoqZVBC1be17g93K1R1vKq/eM39261vxRFRUr8efzW1t/G1FUViNGDbUapCQkJBd/7/+/97vbD/T+n/H9Nw/u/z5/11jr+ZrYP9tH9t/+3v/H0P8+jwtc93N8f8fUzx3/lx8/nHJ8/Tna5Nz6wx/yLuSKcKEhQvkDMg=')))
\ No newline at end of file
diff --git a/irlc/project1/project1_tests.py b/irlc/project1/project1_tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..dd846223725ae942bc57f2ead0768d4e3bb12de1
--- /dev/null
+++ b/irlc/project1/project1_tests.py
@@ -0,0 +1,377 @@
+# This file may not be shared/redistributed without permission. Please read copyright notice in the git repo. If this file contains other copyright notices disregard this text.
+from unitgrade import UTestCase, Report
+from irlc.pacman.gamestate import GameState
+from irlc.pacman.pacman_environment import PacmanEnvironment
+import numpy as np
+from unitgrade import hide
+
+def get_starting_state(name):
+    s0, _ = PacmanEnvironment(layout_str=get_map(name)).reset()
+    return s0
+
+def get_map(name):
+    from irlc.project1.pacman import east, east2, SS0tiny, datadiscs, SS1tiny, SS2tiny
+    names2maps = {'east': east,
+                  'east2': east2,
+                  'datadiscs': datadiscs,
+                  'SS0tiny': SS0tiny,
+                  'SS1tiny': SS1tiny,
+                  'SS2tiny': SS2tiny,
+                  }
+    return names2maps[name]
+
+class Pacman1(UTestCase):
+    """ Problem 1: The go_east function """
+
+    def test_states_length(self):
+        from irlc.project1.pacman import go_east, east
+        self.title = "Checking number of states"
+        self.assertEqualC(len(go_east(east)))
+        # assert False
+
+
+    def test_first_state(self):
+        from irlc.project1.pacman import go_east, east
+        self.title = "Checking first state"
+        self.assertEqualC(str(go_east(east))[0]) # string representation of the first state.
+
+    def test_all_states(self):
+        self.title = "Checking complete output"
+        from irlc.project1.pacman import go_east, east
+        self.assertEqualC(tuple(str(s) for s in go_east(east)))
+
+
+class Pacman3(UTestCase):
+    """ Problem 3: the p_next function without droids """
+    map = 'east'
+    action = 'East'
+
+    def get_transitions(self):
+        from irlc.project1.pacman import p_next
+
+        state = get_starting_state(self.map)
+        state_transitions = p_next(state, self.action)
+        self.assertIsInstance(state_transitions, dict)
+        for x in state_transitions:  # Test if each new state is actually a GameState.
+            self.assertIsInstance(x, GameState)
+        dd = {s: np.round(p, 4) for s, p in state_transitions.items()}
+        return dd
+
+    def test_dictionary_size(self):
+        """ Is the number of keys/values in the dictionary correct? """
+        # print(self.get_expected_test_value())
+        self.assertEqualC(len(self.get_transitions()))
+        # self.get_expected_value()
+
+
+    def test_probabilities(self):
+        """ Does the probabilities have the right value? """
+        self.assertEqualC(set(self.get_transitions().values()))
+
+    def test_states(self):
+        """ Does the dictionary contains the right states """
+        self.assertEqualC(set(self.get_transitions().keys()))
+
+    def test_everything(self):
+        """ Test both states and probabilities """
+        self.assertEqualC(self.get_transitions())
+
+
+class Pacman4(UTestCase):
+    """ Problem 4: Compute the state spaces as a list [S_0, ..., S_N] on the map 'east' using N = 7 """
+    map = 'east'
+    N = 7
+
+    @property
+    def states(self):
+        return self.__class__.states_
+
+    @property
+    def sizes(self):
+        return self.__class__.sizes_
+
+    @classmethod
+    def setUpClass(cls):
+        from irlc.project1.pacman import get_future_states
+        states = get_future_states(get_starting_state(cls.map), cls.N)
+        assert isinstance(states, list)
+        for S in states:
+            assert isinstance(S, list)
+            for s in S:
+                assert isinstance(s, GameState)
+        cls.sizes_ = [len(S) for S in states]
+        cls.states_ = [set(S) for S in states]
+
+    def test_state_space_size_S0(self):
+        self.assertEqualC(self.sizes[0])
+
+    def test_state_space_size_S1(self):
+        self.assertEqualC(self.sizes[1])
+
+    def test_state_space_size_all(self):
+        self.assertEqualC(self.sizes)
+
+    def test_number_of_spaces(self):
+        """ Check the list of state spaces has the right length. It should be N+1 long (S_0, ..., S_N) """
+        self.assertEqualC(len(self.states))
+
+    def test_state_space_0(self):
+        """ Check the first element, the state space S0.
+
+        Hints:
+            * It should be a list containning a single GameState object (the starting state) """
+        self.assertEqualC(self.states[0])
+
+    def test_state_space_1(self):
+        """ Check the second element, the state space S1.
+
+        Hints:
+            * It should be a list containing the GameState objects you can go to in one step.
+            * You should be able to figure out what they are from the description of the game rules. Note pacman will not move if he walks into the walls. """
+        self.assertEqualC(self.states[1])
+
+    def test_state_spaces(self):
+        """ Test all state spaces S_0, ..., S_N
+
+        Hints:
+            * If this method breaks, find the first state space which is wrongly computed, and work out which states are missing or should not be there
+            * I anticipate the won/lost game configurations may become a source of problems. Note you don't have to specify these manually; they should follow by using the s.f(action)-function. """
+
+        self.assertEqualC(tuple(self.states))
+
+
+class Pacman6a(UTestCase):
+    """ Problem 6a: No ghost optimal path (get_shortest_path) in map 'east' using N=20 """
+    map = 'east'
+    N = 20
+
+    def get_shortest_path(self):
+        from irlc.project1.pacman import shortest_path
+        layout = get_map(self.map)
+        actions, states = shortest_path(layout, self.N)
+        return actions, states
+
+    def test_sequence_lengths(self):
+        """ Test the length of the state/action lists. """
+        actions, states = self.get_shortest_path()
+        print("self.map", self.map, 'actions', actions)
+        self.assertEqualC(len(actions))
+        self.assertEqualC(len(states))
+
+    def test_trajectory(self):
+        """ Test the state/action trajectory """
+        actions, states = self.get_shortest_path()
+        self.assertTrue(states[-1].is_won())
+
+        x0 = states[0]
+        for k, u in enumerate(actions):
+            x0 = x0.f(u)
+            self.assertTrue(x0 == states[k + 1])
+        self.assertEqualC(states[1])
+        # self.assertEqualC(J)
+
+class Pacman6b(Pacman6a):
+    """ Problem 6b: No ghost optimal path (get_shortest_path) in map 'SS1tiny' using N=20 """
+    map = 'SS0tiny'
+
+class Pacman6c(Pacman6a):
+    """ Problem 6b: No ghost optimal path (get_shortest_path) in map 'datadiscs' using N=20 """
+    map = 'datadiscs'
+
+## ONE GHOST
+class Pacman7a(Pacman3):
+    """ Problem 7a: the p_next function with one droid """
+    map = 'SS1tiny'
+    action = 'East'
+
+class Pacman7b(Pacman3):
+    """ Problem 7b: the p_next function with one droid """
+    map = 'SS1tiny'
+    action = 'West'
+
+class Pacman8a(Pacman4):
+    """ Problem 5:  Test the state spaces as a list [S_0, ..., S_N]. on the map 'SS1tiny' using N = 4 """
+    map = 'SS1tiny'
+    N = 4
+
+class Pacman8b(Pacman4):
+    """ Problem 6: Test the state spaces as a list [S_0, ..., S_N]. on the map 'SS1tiny' using N = 6 """
+    map = 'SS1tiny'
+    N = 6
+    pass
+
+class Pacman9(UTestCase):
+    """ Problem 9: Testing winrate on the map SS1tiny (win_probability) """
+    map = 'SS1tiny'
+
+    def _win_rate(self, N):
+        self.title = f"Testing winrate in {N} steps"
+        from irlc.project1.pacman import win_probability
+        p = np.round(win_probability(get_map(self.map), N), 4)
+        print("win rate in N ", N, "steps was", p)
+        # print("Testing win rate", self.get_expected_test_value())
+        self.assertEqualC(p)
+
+    def test_win_rate_N4(self):
+        self._win_rate(N=4)
+
+    def test_win_rate_N5(self):
+        self._win_rate(N=5)
+
+    def test_win_rate_N6(self):
+        self._win_rate(N=6)
+
+
+# ## TWO GHOSTS
+class Pacman10(Pacman3): # p_next for two ghosts
+    """ Problem 10: Testing the p_next function using SS2tiny """
+    map = 'SS2tiny'
+    N = 4
+
+class Pacman11(Pacman4): # State-space lists
+    """ Problem 11: Test the state spaces as a list [S_0, ..., S_N]. on the map 'SS2tiny' using N = 3 """
+    map = 'SS2tiny'
+    N = 3
+
+class Pacman12(Pacman9): # Optimal planning for two ghost-droids.
+    """ Problem 12: Testing winrate on the map SS2tiny (win_probability) """
+    map = 'SS2tiny'
+    N = 2
+
+class Kiosk1(UTestCase):
+    """ Problem 14: Warmup check of S_0 and A_0(x_0) """
+    def test_warmup_states_length(self):
+        from irlc.project1.kiosk import warmup_states, warmup_actions
+        n = len(warmup_states())
+        self.title = f"Checking length of state space is {n}"
+        self.assertEqualC(n)
+
+    def test_warmup_actions_length(self):
+        from irlc.project1.kiosk import warmup_states, warmup_actions
+        n = len(warmup_actions())
+        self.title = f"Checking length of action space is {n}"
+        self.assertEqualC(n)
+
+
+    def test_warmup_states(self):
+        self.title = "Checking state space"
+        from irlc.project1.kiosk import warmup_states, warmup_actions
+        self.assertEqualC(set(warmup_states()))
+
+    def test_warmup_actions(self):
+        self.title = "Checking action space"
+        from irlc.project1.kiosk import warmup_states, warmup_actions
+        self.assertEqualC(set(warmup_actions()))
+
+
+class Kiosk2(UTestCase):
+    """ Problem 16: solve_kiosk_1 """
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        from irlc.project1.kiosk import solve_kiosk_1
+        cls.J, cls.pi = solve_kiosk_1()
+
+    def mk_title(self, k, x):
+        self.k = k
+        self.x = x
+
+        if self.k is not None:
+            if self.k != -1:
+                sk = f"N-{-self.k - 1}" if self.k < 0 else str(self.k)
+            else:
+                sk = "N"
+            jp = "J_{" + sk + "}" if len(sk) > 1 else "J_"+sk
+        else:
+            jp = "J_k"
+        if self.x is not None:
+            xp = f"(x={self.x})"
+        else:
+            xp = "(x) for all x"
+        return "Checking cost-to-go " + jp + xp
+
+    def check_J(self, k, x):
+        J = [{k: v for k, v in J_.items()} for J_ in self.__class__.J]
+        t = self.mk_title(k, x)
+        if k is not None and x is not None:
+            t += f" = {J[k][x]}"
+        self.title = t
+
+        if k is not None:
+            J_ = J[k]
+            if x is not None:
+                self.assertAlmostEqualC(J_[x], msg=f"Failed test of J[{k}][{x}]", delta=1e-4)
+                # self.assertL2(J_[x], msg=f"Failed test of J[{k}][{x}]", tol=1e-5)
+            else:
+                for state in sorted(J_.keys()):
+                    self.assertAlmostEqualC(J_[state], msg=f"Failed test of J[{k}][{state}]", delta=1e-4)
+        else:
+            for k, J_ in enumerate(J):
+                for state in sorted(J_.keys()):
+                    self.assertAlmostEqualC(J_[state], msg=f"Failed test of J[{k}][{state}]", delta=1e-4)
+
+    def test_case_1(self):
+        self.check_J(k=-1, x=10)
+
+    def test_case_2(self):
+        self.check_J(k=-2, x=20)
+
+    def test_case_3(self):
+        self.check_J(k=-2, x=0)
+
+    def test_case_4(self):
+        self.check_J(k=0, x=0)
+
+    def test_case_5(self):
+        self.check_J(k=1, x=4)
+
+    def test_case_6(self):
+        self.check_J(k=None, x=None)
+
+
+class Kiosk3(Kiosk2):
+    """ Problem 17: solve_kiosk_2 """
+    @classmethod
+    def setUpClass(cls) -> None:
+        from irlc.project1.kiosk import solve_kiosk_2
+        cls.J, cls.pi = solve_kiosk_2()
+
+
+class Project1(Report): #240 total.
+    title = "02465 project part 1: Dynamical Programming"
+    remote_url = "https://02465material.pages.compute.dtu.dk/02465public/_static/evaluation/"
+    import irlc
+    pack_imports = [irlc]
+    abbreviate_questions = True
+
+    pacman_questions = [
+        (Pacman1, 10), # east
+        (Pacman3, 10), # p_next (g=0)
+        (Pacman4, 10), # future_states (g=0)
+        (Pacman6a, 4), # shortest_path (g=0)
+        (Pacman6b, 3), # shortest_path (g=0)
+        (Pacman6c, 3), # shortest_path (g=0)
+        (Pacman7a, 5), # p_next (g=1)
+        (Pacman7b, 5), # p_next (g=1)
+        (Pacman8a, 5), # future_states (g=1)
+        (Pacman8b, 5), # future_states (g=1)
+        (Pacman9, 10),  # optimal planning (g=1)
+        (Pacman10, 10), # p_next (g=2)
+        (Pacman11, 10), # future_states (g=2)
+        (Pacman12, 10), # optimal planning (g=2)
+                 ]
+
+    kiosk_questions = [
+        (Kiosk1, 10),
+        (Kiosk2, 25),
+        (Kiosk3, 25),
+    ]
+
+    questions = []
+    questions += pacman_questions
+    questions += kiosk_questions
+
+if __name__ == '__main__':
+    from unitgrade import evaluate_report_student
+    evaluate_report_student(Project1())
+# 448, 409 # 303
diff --git a/irlc/project1/unitgrade_data/Kiosk1.pkl b/irlc/project1/unitgrade_data/Kiosk1.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..77935a972bb38c2f6a0b0049567d3c1dcd34b8a4
Binary files /dev/null and b/irlc/project1/unitgrade_data/Kiosk1.pkl differ
diff --git a/irlc/project1/unitgrade_data/Kiosk2.pkl b/irlc/project1/unitgrade_data/Kiosk2.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..b473df178f2b0028ec2a73a01397af4dd716452a
Binary files /dev/null and b/irlc/project1/unitgrade_data/Kiosk2.pkl differ
diff --git a/irlc/project1/unitgrade_data/Kiosk3.pkl b/irlc/project1/unitgrade_data/Kiosk3.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..b473df178f2b0028ec2a73a01397af4dd716452a
Binary files /dev/null and b/irlc/project1/unitgrade_data/Kiosk3.pkl differ
diff --git a/irlc/project1/unitgrade_data/Pacman1.pkl b/irlc/project1/unitgrade_data/Pacman1.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..77606c9d62da4c86930d00b431cead8276f1e032
Binary files /dev/null and b/irlc/project1/unitgrade_data/Pacman1.pkl differ
diff --git a/irlc/project1/unitgrade_data/Pacman10.pkl b/irlc/project1/unitgrade_data/Pacman10.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..f45af44a02f04cd02b950fd05012370184eb11a8
Binary files /dev/null and b/irlc/project1/unitgrade_data/Pacman10.pkl differ
diff --git a/irlc/project1/unitgrade_data/Pacman11.pkl b/irlc/project1/unitgrade_data/Pacman11.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..d7df2b409af8c9ceab168855a1b775e66fde86ec
Binary files /dev/null and b/irlc/project1/unitgrade_data/Pacman11.pkl differ
diff --git a/irlc/project1/unitgrade_data/Pacman12.pkl b/irlc/project1/unitgrade_data/Pacman12.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..a275d890067ce5ed9823bd69c29825457631d328
Binary files /dev/null and b/irlc/project1/unitgrade_data/Pacman12.pkl differ
diff --git a/irlc/project1/unitgrade_data/Pacman3.pkl b/irlc/project1/unitgrade_data/Pacman3.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..f45af44a02f04cd02b950fd05012370184eb11a8
Binary files /dev/null and b/irlc/project1/unitgrade_data/Pacman3.pkl differ
diff --git a/irlc/project1/unitgrade_data/Pacman4.pkl b/irlc/project1/unitgrade_data/Pacman4.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..d7df2b409af8c9ceab168855a1b775e66fde86ec
Binary files /dev/null and b/irlc/project1/unitgrade_data/Pacman4.pkl differ
diff --git a/irlc/project1/unitgrade_data/Pacman6a.pkl b/irlc/project1/unitgrade_data/Pacman6a.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..06b6acc653c46c834e0ea83451ac6ea41478074c
Binary files /dev/null and b/irlc/project1/unitgrade_data/Pacman6a.pkl differ
diff --git a/irlc/project1/unitgrade_data/Pacman6b.pkl b/irlc/project1/unitgrade_data/Pacman6b.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..06b6acc653c46c834e0ea83451ac6ea41478074c
Binary files /dev/null and b/irlc/project1/unitgrade_data/Pacman6b.pkl differ
diff --git a/irlc/project1/unitgrade_data/Pacman6c.pkl b/irlc/project1/unitgrade_data/Pacman6c.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..06b6acc653c46c834e0ea83451ac6ea41478074c
Binary files /dev/null and b/irlc/project1/unitgrade_data/Pacman6c.pkl differ
diff --git a/irlc/project1/unitgrade_data/Pacman7a.pkl b/irlc/project1/unitgrade_data/Pacman7a.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..f45af44a02f04cd02b950fd05012370184eb11a8
Binary files /dev/null and b/irlc/project1/unitgrade_data/Pacman7a.pkl differ
diff --git a/irlc/project1/unitgrade_data/Pacman7b.pkl b/irlc/project1/unitgrade_data/Pacman7b.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..f45af44a02f04cd02b950fd05012370184eb11a8
Binary files /dev/null and b/irlc/project1/unitgrade_data/Pacman7b.pkl differ
diff --git a/irlc/project1/unitgrade_data/Pacman8a.pkl b/irlc/project1/unitgrade_data/Pacman8a.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..d7df2b409af8c9ceab168855a1b775e66fde86ec
Binary files /dev/null and b/irlc/project1/unitgrade_data/Pacman8a.pkl differ
diff --git a/irlc/project1/unitgrade_data/Pacman8b.pkl b/irlc/project1/unitgrade_data/Pacman8b.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..d7df2b409af8c9ceab168855a1b775e66fde86ec
Binary files /dev/null and b/irlc/project1/unitgrade_data/Pacman8b.pkl differ
diff --git a/irlc/project1/unitgrade_data/Pacman9.pkl b/irlc/project1/unitgrade_data/Pacman9.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..a275d890067ce5ed9823bd69c29825457631d328
Binary files /dev/null and b/irlc/project1/unitgrade_data/Pacman9.pkl differ
diff --git a/irlc/tests/unitgrade_data/Problem1BobsFriend.pkl b/irlc/tests/unitgrade_data/Problem1BobsFriend.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..073cc3abaf79e5c9ce49838c8f63933844682176
Binary files /dev/null and b/irlc/tests/unitgrade_data/Problem1BobsFriend.pkl differ
diff --git a/irlc/tests/unitgrade_data/Problem2BobsPolicy.pkl b/irlc/tests/unitgrade_data/Problem2BobsPolicy.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..b85b7a79f12650ab08c5e1b1846b6dd94e07401e
Binary files /dev/null and b/irlc/tests/unitgrade_data/Problem2BobsPolicy.pkl differ
diff --git a/irlc/tests/unitgrade_data/Problem3InventoryInventoryEnvironment.pkl b/irlc/tests/unitgrade_data/Problem3InventoryInventoryEnvironment.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..b122de5cb99d8111d9f14630edf22a4f3b6f8caa
Binary files /dev/null and b/irlc/tests/unitgrade_data/Problem3InventoryInventoryEnvironment.pkl differ
diff --git a/irlc/tests/unitgrade_data/Problem4InventoryTrain.pkl b/irlc/tests/unitgrade_data/Problem4InventoryTrain.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..65e8a95eca52ccb875699d342f28839299a696b3
Binary files /dev/null and b/irlc/tests/unitgrade_data/Problem4InventoryTrain.pkl differ
diff --git a/irlc/tests/unitgrade_data/Problem5PacmanHardcoded.pkl b/irlc/tests/unitgrade_data/Problem5PacmanHardcoded.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..4b90516956cebe85cdf12481939260cb04f7c151
Binary files /dev/null and b/irlc/tests/unitgrade_data/Problem5PacmanHardcoded.pkl differ
diff --git a/irlc/tests/unitgrade_data/Problem6ChessTournament.pkl b/irlc/tests/unitgrade_data/Problem6ChessTournament.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..7bdaed17849541d8d61653d1e5dd5c82f35206e4
Binary files /dev/null and b/irlc/tests/unitgrade_data/Problem6ChessTournament.pkl differ
diff --git a/irlc/utils/async_wrappers.py b/irlc/utils/async_wrappers.py
new file mode 100644
index 0000000000000000000000000000000000000000..8dbebf533885664ea41f1a9d01e5012a20ec4490
--- /dev/null
+++ b/irlc/utils/async_wrappers.py
@@ -0,0 +1,39 @@
+# This file may not be shared/redistributed without permission. Please read copyright notice in the git repo. If this file contains other copyright notices disregard this text.
+from gymnasium.wrappers import TimeLimit
+
+from irlc.pacman.pacman_environment import PacmanWinWrapper
+
+
+
+
+class AsyncPacmanWinWrapper(PacmanWinWrapper):
+    async def async_step(self, action):
+        observation, reward, done, truncated, info = await self.env.async_step(action)
+        if self.env.unwrapped.game.state.is_won():
+            reward = 1
+        else:
+            reward = 0
+        return observation, reward, done, truncated, info
+
+
+class AsyncTimeLimit(TimeLimit):
+    # def __init__(s
+
+    async def async_step(self, action):
+        """Steps through the environment and if the number of steps elapsed exceeds ``max_episode_steps`` then truncate.
+
+        Args:
+            action: The environment step action
+
+        Returns:
+            The environment step ``(observation, reward, terminated, truncated, info)`` with `truncated=True`
+            if the number of steps elapsed >= max episode steps
+
+        """
+        observation, reward, terminated, truncated, info = await self.env.async_step(action)
+        self._elapsed_steps += 1
+
+        if self._elapsed_steps >= self._max_episode_steps:
+            truncated = True
+
+        return observation, reward, terminated, truncated, info
diff --git a/irlc/utils/bandit_graphics_environment.py b/irlc/utils/bandit_graphics_environment.py
new file mode 100644
index 0000000000000000000000000000000000000000..391f0ea5f31d49a4bc70edddc624eb8d27fd018c
--- /dev/null
+++ b/irlc/utils/bandit_graphics_environment.py
@@ -0,0 +1,340 @@
+# This file may not be shared/redistributed without permission. Please read copyright notice in the git repo. If this file contains other copyright notices disregard this text.
+import pygame.draw
+import pygame
+from irlc.ex08.bandits import StationaryBandit
+import time
+import numpy as np
+from irlc.pacman.pacman_resources import WHITE, BLACK, Ghost
+
+
+class BinaryBandit(StationaryBandit):
+    def reset(self):
+        # self.q_star = np.random.rand(self.k) + self.q_star_mean
+        self.q_star = np.ones(self.k)/3
+        self.q_star[np.random.randint(self.k)] *= 2
+        self.optimal_action = np.argmax(self.q_star)
+        self.previous_action = None
+        self.reward = None
+        return None, {}
+
+    def bandit_step(self, a):
+        """ Return the reward/regret for action a for the simple bandit. Use self.q_star (see reset) """
+        reward = np.random.rand() < self.q_star[a]
+        regret = self.q_star[self.optimal_action] - self.q_star[a]
+        self.previous_action = a
+        self.reward = reward
+        return reward, regret
+
+
+class GraphicalBandit(BinaryBandit):
+    viewer = None
+    metadata = {'render_modes': ['human', 'rgb_array'],
+                'render_fps': 20}
+
+    def get_keys_to_action(self):
+        return {(pygame.K_0,):0, (pygame.K_1,): 1, (pygame.K_2,): 2, (pygame.K_3,): 3, (pygame.K_4,): 4,
+                (pygame.K_5,): 5, (pygame.K_6,): 6, (pygame.K_7,): 7, (pygame.K_8,): 8, (pygame.K_9,): 9,
+                # (pygame.K_0,):0
+                }
+
+    def __init__(self, *args, render_mode='human', frames_per_second=None, **kwargs):
+        self.previous_reward, self.previous_action, self.agent = None, None, None
+        super().__init__( *args, **kwargs)
+        self.render_mode = render_mode
+        self.viewer = None
+        self.show_q_star = False
+        self.show_q_ucb = False
+        self.frames_per_second = frames_per_second
+
+        print("press q to show true q values and u to show UCB upper bounds.")
+
+    def reset(self):
+        s, info = super().reset()
+        self.render()
+        return s, info
+
+    def step(self, action):
+        o = super().step(action)
+        self.previous_action = action
+        self.previous_reward = o[1]
+        self.render()
+        return o
+
+    def keypress(self, key):
+        # print(key)
+        if key.unicode == 'q':
+            self.viewer.show_q_star = not self.viewer.show_q_star
+
+        if key.unicode == 'u':
+            self.viewer.show_q_ucb = not self.viewer.show_q_ucb
+        self.render()
+
+    def render(self, mode='human', agent=None, prev_action=None, reward=None):
+        if self.viewer is None:
+            self.viewer = BanditViewer(self, frames_per_second=self.frames_per_second)
+        self.viewer.update(self.agent, self.previous_action, self.previous_reward)
+        return self.viewer.blit(render_mode=self.render_mode) #(return_rgb_array=mode == 'rgb_array')
+
+    def close(self):
+        self.viewer.close()
+
+class BanditViewer:
+    scale = 400  # Scale of a single bar.
+    width = 0.4 * scale  # with of a bar.
+    bar_height = scale
+
+    def __init__(self, bandit, frames_per_second=None):
+        bin_bandit = isinstance(bandit, BinaryBandit)
+        if bin_bandit:
+            ymin = 0 - 0.6 * self.scale
+            ymax = (1 + 0.4)* self.scale
+        else:
+            ymin = (min(bandit.q_star) - 0.6)*self.scale
+            ymax = (max(bandit.q_star) + 0.4)*self.scale
+
+        xmin = -self.width
+        xmax = (bandit.k * self.width  + self.width)
+        # super().__init__(screen_width=1300, xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax)
+        from irlc.utils.graphics_util_pygame import GraphicsUtilGym
+        dx = xmax-xmin
+        dy = ymax-ymin
+
+        # screen_width = 1300, xmin = xmin, xmax = xmax, ymin = ymin, ymax = ymax
+        self.ga = GraphicsUtilGym()
+        screen_width = 1300
+        self.ga.begin_graphics(screen_width, dy * (screen_width / dx), local_xmin_xmax_ymin_ymax=(xmin, xmax, ymax, ymin), frames_per_second=frames_per_second)
+        self.bandit = bandit
+        self.ghost = Ghost(self.ga, scale=100)
+
+        # self.ghost.surf = pygame.transform.scale(self.ghost.surf, (self.ghost.surf.get_width()*0.4, self.ghost.surf.get_height()*0.4) )
+        # self.ghost.rect = self.ghost.surf.get_rect()
+        # self.ghost.rect.x = self.width / 2
+        # self.ghost.rect.y = -self.scale
+
+        self.last_action = None
+        self.agent = None
+        self.last_reward = None
+
+        self.show_q_star = False
+        self.show_q_ucb = False
+        # self.ghost.group.scale(self.width*0.4)
+        # self.ghost.group.translate(self.width / 2, -self.scale)
+
+    def close(self):
+        self.ga.close()
+
+    def blit(self, render_mode='human'):
+        return self.ga.blit(render_mode=render_mode)
+
+    def master_render(self):
+        self.ga.draw_background()
+        # batch = pyglet.graphics.Batch()
+        # self.ghosts = pyglet.graphics.Batch()
+        # return
+        self.q_star = []
+        self.q_ucb_upper = []
+        self.Qs = []
+        # bgg = OrderedGroup(-1)
+        # self.bg = [shapes.Rectangle(xmin, ymin, xmax-xmin, ymax-ymin, color=(0,0,0), batch=batch, group=bgg)]
+
+        dd = self.width / 30
+        self.text_n = []
+        fz = int(self.width / 6)
+
+        dw = self.width / 4
+
+        # group = OrderedGroup(1)
+        for i in range(self.bandit.k):
+            x = i * self.width
+            # print(x)
+            # from pyglet import shapes
+            # from pyglet.shapes import Rectangle
+            # self.bg.append(shapes.Rectangle(20, 30, 100,100, color=(100,10,10), batch=batch,group=group))
+
+            # pygame.draw.rect()
+            # self.ga.polygon()
+            # self.ga.rectangle(self.ga.surf, WHITE, pygame.Rect)
+            self.ga.rectangle(WHITE, x-dd, -dd, self.width/2+dd*2, self.bar_height+dd*2, border=0)
+            self.ga.rectangle(BLACK, x, 0, self.width/2, self.bar_height, border=0)
+
+            if self.agent is not None and hasattr(self.agent, 'Q'):
+                # height =
+                # print(self.agent.Q[i] * self.bar_height)
+                self.ga.rectangle((150, 200, 150), x, 0, self.width / 2, self.agent.Q[i] * self.bar_height)  # q-values.
+
+            # self.ga.rectangle((150,200,150), x, 0, self.width / 2, 0, ) # q-values.
+
+            self.ga.text("sadf", (x + self.width / 4, self.bar_height + dw * 2), WHITE, contents=f"Arm  {i}",
+                         size=fz,
+                         style='bold')
+            if self.agent is not None:
+                self.ga.text("sadf", (x + self.width / 4, self.bar_height + dw), WHITE, contents= f"N = {int(self.agent.N[i] if hasattr(self.agent, 'N') else 0)}", size=fz,
+                             style='bold')
+
+
+
+            # return
+            # continue
+            # return
+            # self.bg.append(shapes.Rectangle(x-dd, -dd, self.width/2+dd*2, self.bar_height+dd*2, color=WHITE,batch=batch,group=group))
+            # self.bg.append(shapes.Rectangle(x, 0, self.width/2, self.bar_height, color=BLACK, batch=batch,group=group))
+            # return
+            # self.Qs.append(shapes.Rectangle(x, 0, self.width/2, .0, color=(150,200,150), batch=batch,group=group))
+
+            # q_star = shapes.Rectangle(x, 0, self.width / 2, dd, color=WHITE, batch=batch,group=group)
+            # self.q_star_visible = False
+            if self.show_q_star:
+
+                y =  self.bandit.q_star[i] * self.bar_height
+                self.ga.rectangle(WHITE, x, y, self.width / 2, dd)  # q-star
+                # print(x, y)
+
+            # q_star.visible = False
+            # self.q_star.append(q_star)
+            # self.q_ucb_visible = False
+            if self.show_q_ucb:
+                from irlc.ex08.ucb_agent import UCBAgent
+                # if :
+                if (hasattr(self.agent, 'c') or isinstance(self.agent, UCBAgent)) and hasattr(self.agent, 'N'):  # Required if reset has not been called.
+                    t = (sum(self.agent.N) + 1e-8)
+                    ub = self.agent.Q + self.agent.c * np.sqrt(np.log(t + 1) / (self.agent.N + 1e-8))
+                    self.ga.rectangle((200, 0, 0), x, ub[i] * self.bar_height, self.width / 2, dd)
+                # q_ucb = shapes.Rectangle(x, -1000, self.width / 2, dd, color=(200, 0, 0), batch=batch,group=group)
+            # q_ucb.visible = False
+            # self.q_ucb_upper.append(q_ucb)
+
+            # self.q_star = []
+            # for i, b in enumerate(self.q_star):
+            #     continue
+            #     b.y = self.bandit.q_star[i] * self.bar_height
+            # print(ub)
+            # self.bg.append(Label(f"Arm  {i}", font_name='Arial', x=x+self.width/4, y=self.bar_height + dw*2, anchor_x='center', bold=True, color=(255, 255, 255, 255), anchor_y='center', font_size=fz, batch=batch, group=group))
+            # self.text_n.append(Label(f"N = {0}", font_name='Arial', x=x+self.width/4, y=self.bar_height + dw, anchor_x='center', bold=True, color=(255, 255, 255, 255), anchor_y='center', font_size=fz, batch=batch, group=group))
+        if self.agent is not None:
+            self.ga.text("sadf", (self.width / 2, self.bar_height + dw * 3), WHITE,
+                         contents=f"{self.agent.method if hasattr(self.agent, 'method') else ''}", size=fz,
+                         style='bold', anchor='c')
+        reward = self.last_reward
+        action = self.last_action
+        self.ghost.set_direction(self.ghost.rand_eyes()) # Random eyes.
+        if reward is not None:
+            if reward <= 0:
+                self.ghost.kill()
+            else:
+                self.ghost.resurrect()
+            last_outcome_x =  (action+0.25)*self.width
+            last_outcome_y = reward
+            self.ga.circle("cc", (last_outcome_x, last_outcome_y), self.width / 10, fillColor=WHITE, outlineColor=None)
+
+            # self.last_outcome.x = (action+0.25)*self.width
+            # self.last_outcome.y = reward
+        else:
+            pass
+            # self.last_outcome.x = -self.scale
+
+        if action is None:
+            action = -0.5
+
+        y2 = -0.45*self.width - 0.25 * self.width
+        x2 = (action+.25) * self.width
+        self.ghost.set_position(x2, y2)
+        self.ghost.render()
+        return
+        # for i, b in enumerate(self.q_star):
+        #     b.y = self.bandit.q_star[i]* self.bar_height
+        #
+        #     from irlc.ex08.ucb_agent import UCBAgent
+        #     if isinstance(agent, UCBAgent) and hasattr(agent, 'N'): # Required if reset has not been called.
+        #         t = sum(agent.N)
+        #         ub = agent.Q + agent.c * np.sqrt(np.log(t + 1) / (agent.N + 1e-8))
+        #
+        #         for i, b in enumerate(self.q_ucb_upper):
+        #             b.y = ub[i]* self.bar_height
+        #
+        #         # print(ub)
+        #     s = 234
+
+        # self.last_outcome = shapes.Circle(-self.scale, 0, self.width/10, color=WHITE, batch=batch,group=group)
+        # self.batch = batch
+
+    def update(self, agent, action, reward):
+        self.agent = agent
+        self.last_action = action
+        self.last_reward = reward
+        self.master_render()
+
+        # return
+        # # return
+        #
+        # # if action is not None:
+        # #     y2 = -0.45*self.width
+        # #     x2 = (action+.25) * self.width
+        # #     self.ghost.set_position(x2, y2)
+        #
+        #
+        # # dd = self.width / 30
+        # self.text_n = []
+        # # group = OrderedGroup(1)
+        # for i in range(self.bandit.k):
+        #     x = i * self.width
+        #     # print(x)
+        #     # from pyglet import shapes
+        #     # from pyglet.shapes import Rectangle
+        #     # self.bg.append(shapes.Rectangle(20, 30, 100,100, color=(100,10,10), batch=batch,group=group))
+        #
+        #     # pygame.draw.rect()
+        #     # self.ga.polygon()
+        #     # self.ga.rectangle(self.ga.surf, WHITE, pygame.Rect)
+        #     self.ga.rectangle(WHITE, x - dd, -dd, self.width / 2 + dd * 2, self.bar_height + dd * 2, border=0)
+        #     self.ga.rectangle(BLACK, x, 0, self.width / 2, self.bar_height, border=0)
+        #
+        #
+        #     dw = self.width / 4
+        #     fz = int(self.width / 6)
+        #
+        #     # for i, b in enumerate(self.Qs):
+        #     if agent is not None:
+        #         if hasattr(agent, 'Q'):
+        #             height = agent.Q[i] * self.bar_height
+        #             self.ga.rectangle((150, 200, 150), x, 0, self.width / 2, height)  # q-values.
+        #
+        #         if hasattr(agent, 'N'):
+        #             nlabel = f"N = {int(agent.N[i])}"
+        #             self.ga.text("sadf", (x + self.width / 4, self.bar_height + dw), WHITE, contents=nlabel,
+        #                          size=fz,
+        #                          style='bold', anchor='c')
+        #
+        #             # self.text_n[i].text =
+        #
+        #     self.ga.text("sadf", (x + self.width / 4, self.bar_height + dw * 2), WHITE, contents=f"Arm  {i}",
+        #                  size=fz,
+        #                  style='bold', anchor='c')
+        #
+        # return
+
+
+    # def draw(self):
+    #     self.batch.draw()
+    #     self.ghosts.draw()
+
+
+if __name__ == "__main__":
+    env = GraphicalBandit(10, render_mode='human')
+    from irlc import train
+    from irlc.ex08.ucb_agent import UCBAgent
+    # from irlc.utils.player_wrapper import PlayWrapper
+    from irlc import interactive
+    # agent = BasicAgent(env, epsilon=0.1)
+    agent = UCBAgent(env)
+
+    # env = VideoMonitor(env, agent=agent)
+    env, agent = interactive(env, agent)
+
+    # agent = PlayWrapper(agent, env)
+
+    t0 = time.time()
+    n = 500
+    stats, _ = train(env, agent, max_steps=n, num_episodes=10, return_trajectory=False, verbose=False)
+    tpf = (time.time()-t0)/ n
+    print("tpf", tpf, 'fps', 1/tpf)
+    env.close()
diff --git a/irlc/utils/graphics_util_pygame.py b/irlc/utils/graphics_util_pygame.py
index ca4b67d13ee2a411e6ea73ede7d8a5b09c47f8e5..025e6a8e26798448a92a8975cd4d9247af231df9 100644
--- a/irlc/utils/graphics_util_pygame.py
+++ b/irlc/utils/graphics_util_pygame.py
@@ -242,7 +242,9 @@ class GraphicsUtilGym:
 
     def draw_background(self, background_color=None):
         if background_color is None:
-            background_color = (0, 0, 0)
+            # background_color = (0, 0, 0)
+            background_color = self._bg_color
+
         self._bg_color = background_color
         x1, x2, y1, y2 = self._local_xmin_xmax_ymin_ymax
         corners = [ (x1, y1), (x2, y1), (x2, y2), (x1, y2)  ]
diff --git a/irlc/utils/player_wrapper.py b/irlc/utils/player_wrapper.py
index 74296f5f5eb5680650d0765b58c3a411b5edbf59..e84b48fec75e81c155a330565979af3a2cd6fe6d 100644
--- a/irlc/utils/player_wrapper.py
+++ b/irlc/utils/player_wrapper.py
@@ -127,13 +127,13 @@ async def _webassembly_interactive(env, agent, autoplay=False):
         #     s, info = env.reset()
         #     continue
 
-        sp, reward, done, _, info_sp = (await env.async_step(a)) if hasattr(env, 'async_step') else env.step(a)
+        sp, reward, done, truncated, info_sp = (await env.async_step(a)) if hasattr(env, 'async_step') else env.step(a)
 
         agent.train(s, a, reward, sp, done=done, info_s=info, info_sp=info_sp)
 
         step = step + 1
         k = k + 1
-        if done:
+        if done or truncated:
             sp, info_sp = env.reset()
             k = 0
 
@@ -211,6 +211,8 @@ class PlayWrapperPygame(AgentWrapper):
 
         agent.train = train_
         env.agent = agent
+        env.unwrapped.agent = agent
+
         env.reset = reset_
         env.step = step_
 
@@ -298,61 +300,61 @@ class PlayWrapperPygame(AgentWrapper):
                 if a is not None:
                     # print("Breaking", a)
                     break
-                if False:
-                    if event.type == pygame.QUIT:
-                        if hasattr(self, 'env'):
-                            self.env.close()
-                        time.sleep(0.1)
-                        pygame.display.quit()
-                        time.sleep(0.1)
-                        pygame.quit()
-                        time.sleep(0.1)
-                        sys.exit()
-
-                    # checking if keydown event happened or not
-                    if event.type == pygame.KEYDOWN:
-                        if event.key == pygame.K_SPACE:
-                            a = pi_action
-                            break
-                        elif (event.key,) in self.keys_to_action:
-                            a = self.keys_to_action[(event.key,)]
-                            if info is not None and 'mask' in info:
-                                from irlc.utils.common import DiscreteTextActionSpace
-                                if isinstance(self.env.action_space, DiscreteTextActionSpace):
-                                    aint = self.env.action_space.actions.index(a)
-                                else:
-                                    aint = a
-
-                                if info['mask'][aint] == 0:
-                                    # The action was masked. This means that this action is unavailable, and we should select another.
-                                    # The default is to select one of the available actions from the mask.
-                                    a = info['mask'].argmax()
-                                    if isinstance(self.env.action_space, DiscreteTextActionSpace):
-                                        a = self.env.action_space.actions[a]
-                                break
-                            else:
-                                break
-                        elif event.key == pygame.K_r:
-                            print("Pressing r")
-                            if hasattr(self, 'reset'):
-                                return PlayWrapperPygame.ACTION_FORCE_RESET
-                            #
-                            #     self.reset()
-                            #     self.env.reset()
-                            #
-                            # self.env.render()
-                        elif event.key == pygame.K_f:
-                            print("Pressing f")
-                            self.env.render()
-
-                        elif event.unicode == 'p':
-                            # unpause
-                            self.human_demand_autoplay = not self.human_demand_autoplay
-                            break
-                        else:
-                            # try to pass event on to the game.
-                            if hasattr(self.env, 'keypress'):
-                                self.env.keypress(event)
+                # if False:
+                #     if event.type == pygame.QUIT:
+                #         if hasattr(self, 'env'):
+                #             self.env.close()
+                #         time.sleep(0.1)
+                #         pygame.display.quit()
+                #         time.sleep(0.1)
+                #         pygame.quit()
+                #         time.sleep(0.1)
+                #         sys.exit()
+                #
+                #     # checking if keydown event happened or not
+                #     if event.type == pygame.KEYDOWN:
+                #         if event.key == pygame.K_SPACE:
+                #             a = pi_action
+                #             break
+                #         elif (event.key,) in self.keys_to_action:
+                #             a = self.keys_to_action[(event.key,)]
+                #             if info is not None and 'mask' in info:
+                #                 from irlc.utils.common import DiscreteTextActionSpace
+                #                 if isinstance(self.env.action_space, DiscreteTextActionSpace):
+                #                     aint = self.env.action_space.actions.index(a)
+                #                 else:
+                #                     aint = a
+                #
+                #                 if info['mask'][aint] == 0:
+                #                     # The action was masked. This means that this action is unavailable, and we should select another.
+                #                     # The default is to select one of the available actions from the mask.
+                #                     a = info['mask'].argmax()
+                #                     if isinstance(self.env.action_space, DiscreteTextActionSpace):
+                #                         a = self.env.action_space.actions[a]
+                #                 break
+                #             else:
+                #                 break
+                #         elif event.key == pygame.K_r:
+                #             print("Pressing r")
+                #             if hasattr(self, 'reset'):
+                #                 return PlayWrapperPygame.ACTION_FORCE_RESET
+                #             #
+                #             #     self.reset()
+                #             #     self.env.reset()
+                #             #
+                #             # self.env.render()
+                #         elif event.key == pygame.K_f:
+                #             print("Pressing f")
+                #             self.env.render()
+                #
+                #         elif event.unicode == 'p':
+                #             # unpause
+                #             self.human_demand_autoplay = not self.human_demand_autoplay
+                #             break
+                #         else:
+                #             # try to pass event on to the game.
+                #             if hasattr(self.env, 'keypress'):
+                #                 self.env.keypress(event)
 
             if self.human_demand_autoplay:
                 a = pi_action