Demonstration.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1cd12ffa",
   "metadata": {},
   "source": [
    "## Implementation of the MDP Order Dispatching Policy\n",
    "\n",
    "In this notebook, we will design a toy example to simulate the ridesharing market and implement the MDP order dispatch policy. Although the algorithm is being motivated by applications in ridesharing platforms, similar ideas can be employed in other two sided marketplaces (e.g., food delivery companies) that involve sequential decision making over time and space as well."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9877c0a",
   "metadata": {},
   "source": [
    "First, let us import all the required modules. Here, the [`linear_sum_assignment`](https://docs.scipy.org/doc/scipy-0.18.1/reference/generated/scipy.optimize.linear_sum_assignment.html) function from `scipy.optimize` allows us to solve matching problem to assign drivers to call orders by maximizing the advantage function or minimizing the total distance. It is designed to solve the general linear sum assignment problem, e.g., \n",
    "\\begin{eqnarray*}\n",
    "    \\sum_{i=1}^m \\sum_{j=1}^n C_{i,j} a_{i,j},\n",
    "\\end{eqnarray*}\n",
    "where $C_{i,j}$ is the cost of matching vertex $i$ of the first set (e.g., drivers) to vertex $j$ of the second set (e.g., orders) and $a_{i,j}$ equals 1 if $i$ and $j$ are matched and 0 otherwise. In addition, each row is assignment to at most one column, and each column to at most one row. If it has more rows than columns, then not every row needs to be assigned to a column, and vice versa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "be9eb311",
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import count\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import scipy.stats as stats\n",
    "from scipy.optimize import linear_sum_assignment \n",
    "from scipy.sparse.csgraph import min_weight_full_bipartite_matching"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4081cda9",
   "metadata": {},
   "source": [
    "We next detail the experimental setup. Consider orders and drivers operating in a simple map of 9 × 9 spatial grids with 20 time steps. Meanwhile, orders can only be dispatched to drivers in Manhattan distance that are no greater than 2. An order will be canceled if not being assigned to any driver for a long time, with the cancelation time modeled as a truncated Gaussian in the range 0 to 5 with mean 2.5 and standard deviation 2 along the temporal axis."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72506a54",
   "metadata": {},
   "source": [
    "The Manhattan distance is different from the Euclidean distance. See the following figure for details. Take from [here](https://www.researchgate.net/publication/343237167_Game_AI_techniques_applied_to_city_simulations)\n",
    "\n",
    "<img src=\"./graph/manhattan_distance.png\"  width=\"750\"/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "db8b4c49",
   "metadata": {},
   "outputs": [],
   "source": [
    "NUMBER_OF_GRID_TILES_X = 9\n",
    "NUMBER_OF_GRID_TILES_Y= 9\n",
    "NUMBER_OF_TIME_STEPS = 20 \n",
    "\n",
    "MAX_MANHATTAN_DISTANCE = 2\n",
    "\n",
    "def manhattan_distance(p1,p2):\n",
    "    return np.abs(p1[0]-p2[0]) + np.abs(p1[1]-p2[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48f6e95d",
   "metadata": {},
   "source": [
    "We fix the number of orders to 100. The following code allows us to generate waiting time for all the orders. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "fa5dcdaf",
   "metadata": {},
   "outputs": [],
   "source": [
    "NUMBER_OF_ORDERS = 100\n",
    "\n",
    "LOWER_BOUND_WAITING_TIME = 0\n",
    "UPPER_BOUND_WAITING_TIME = 5\n",
    "MEAN_WAITING_TIME = 2.5\n",
    "STANDARD_DEVIATION_WAITING_TIME = 2\n",
    "\n",
    "waiting_time_sampler = stats.truncnorm(\n",
    "    (LOWER_BOUND_WAITING_TIME - MEAN_WAITING_TIME) / STANDARD_DEVIATION_WAITING_TIME, (UPPER_BOUND_WAITING_TIME - MEAN_WAITING_TIME) / STANDARD_DEVIATION_WAITING_TIME, loc=MEAN_WAITING_TIME, scale=STANDARD_DEVIATION_WAITING_TIME)\n",
    "\n",
    "waiting_times = waiting_time_sampler.rvs(NUMBER_OF_ORDERS)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a17ad6e",
   "metadata": {},
   "source": [
    "For data generation, we want to simulate realistic traffic patterns with a morning-peak and a night-peak, centralized on different locations of residential areas and working areas, respectively. Therefore, orders’ starting locations are sampled according to a two-component mixture of Gaussians and then truncated to integers in the spatiotemporal grids. Afterwards, orders' destinations and drivers' initial locations are randomly sampled from a discrete uniform distribution defined on the grids. Parameters of the mixture of Gaussians are as follows.\n",
    "\n",
    "\\begin{eqnarray*}\n",
    "    \\pi^{(1)}=1/3, &\\,\\,& \\pi^{(2)}=2/3;\\\\\n",
    "    \\mu^{(1)}=[3,3,5], &\\,\\,& \\mu^{(2)}=[6,6,15];\\\\\n",
    "    \\sigma^{(1)}=[2,2,3], &\\,\\,& \\sigma^{(2)}=[2,2,3].\n",
    "\\end{eqnarray*}\n",
    "\n",
    "The following code allows us to generate random samples from the two-component mixture distribution. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "3103eb2a",
   "metadata": {},
   "outputs": [],
   "source": [
    "PROBABILITY_FIRST_GAUSSIAN = 1./3\n",
    "PROBABILITY_SECOND_GAUSSIAN = 2./3\n",
    "\n",
    "MEAN_FIRST_GAUSSIAN = [3,3,5]\n",
    "MEAN_SECOND_GAUSSIAN = [6,6,15]\n",
    "\n",
    "STANDARD_DEVIATION_FIRST_GAUSSIAN = [2,2,3]\n",
    "STANDARD_DEVIATION_SECOND_GAUSSIAN = [2,2,3]\n",
    "\n",
    "LOWER_LIMITS_BY_DIMENSION = [0 for _ in range(3)]\n",
    "UPPER_LIMITS_BY_DIMENSION = [NUMBER_OF_GRID_TILES_X - 1, NUMBER_OF_GRID_TILES_Y - 1, NUMBER_OF_TIME_STEPS - 1]\n",
    "\n",
    "class TruncatedMultivariateNormalInteger():\n",
    "    def __init__(self, normals):\n",
    "        self._normals = []\n",
    "        for [lower, upper, mean, standard_deviation] in normals:\n",
    "            X = stats.truncnorm(\n",
    "    (lower - mean) / standard_deviation, (upper - mean) / standard_deviation, loc=mean, scale=standard_deviation)\n",
    "            self._normals.append(X)\n",
    "    # size equals 3 (e.g., 3 independent truncated normals per mixture component) in our example\n",
    "    def rvs(self, size):\n",
    "        return np.array([[normal.rvs(size=1) for normal in self._normals] for _ in range(size)])\n",
    "\n",
    "class MixtureModel():\n",
    "    def __init__(self, submodels, weights, *args, **kwargs):\n",
    "        super().__init__(*args, **kwargs)\n",
    "        self.submodels = submodels\n",
    "        self.weights = weights/np.sum(weights) \n",
    "\n",
    "    def rvs(self, size):\n",
    "        rvs = [] \n",
    "        for i in range(size):\n",
    "            random_model = np.random.choice(range(len(self.submodels)), p=self.weights)\n",
    "            rvs.append(self.submodels[random_model].rvs(size=1))\n",
    "        return np.round(np.squeeze(np.array(rvs))).astype(int)\n",
    "    \n",
    "first_truncated_multivariate_normal = TruncatedMultivariateNormalInteger([[LOWER_LIMITS_BY_DIMENSION[i], UPPER_LIMITS_BY_DIMENSION[i], MEAN_FIRST_GAUSSIAN[i], STANDARD_DEVIATION_FIRST_GAUSSIAN[i]] for i in range(3)])\n",
    "\n",
    "second_truncated_multivariate_normal = TruncatedMultivariateNormalInteger([[LOWER_LIMITS_BY_DIMENSION[i], UPPER_LIMITS_BY_DIMENSION[i], MEAN_SECOND_GAUSSIAN[i], STANDARD_DEVIATION_SECOND_GAUSSIAN[i]] for i in range(3)])\n",
    "\n",
    "mixture_gaussian_model = MixtureModel([first_truncated_multivariate_normal, second_truncated_multivariate_normal],[1./3,2./3])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f60d112",
   "metadata": {},
   "source": [
    "The following code allows us to randomly generate the orders' destinations and drivers' initial locations from a discrete uniform distribution on the grids"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "845168e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def spawn_uniformly_x_y_location():\n",
    "    return [np.random.choice(range(NUMBER_OF_GRID_TILES_X)), np.random.choice(range(NUMBER_OF_GRID_TILES_Y))]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c8411c2",
   "metadata": {},
   "source": [
    "We next calculate the reward associated with each trip. In this example, we use the completion rate (e.g., the percentage of orders being completed) as our objective. As such, for each order, the immediate reward is a binary variable, depending on whether it is being completed or not. \n",
    "\n",
    "We adopt a discounted setting. The discounted factor is fixed to 0.9. Recall from the lecture that the discounted reward is calculated in the following manner. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e304092",
   "metadata": {},
   "source": [
    "<img src=\"./graph/discount_reward.png\"  width=\"750\"/>\n",
    "\n",
    "The following function calculates the discounted reward based on the observed reward."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "aa746ee6",
   "metadata": {},
   "outputs": [],
   "source": [
    "DISCOUNT_FACTOR = 0.9\n",
    "\n",
    "def discounted_reward_mdp(gamma, T, R):\n",
    "    total_gamma = 0\n",
    "    discounted_gamma = 1\n",
    "    for _ in range(T):\n",
    "        total_gamma += discounted_gamma \n",
    "        discounted_gamma *= gamma\n",
    "    return total_gamma * R / T"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96ccd630",
   "metadata": {},
   "source": [
    "Next, we start to implement the MDP order dispatch policy. Recall from the lecture that the algorithm consists of two steps, corresponding to policy evaluation based on temporal difference learning and order dispatch by maximizing the total advantage function. Consider the policy evaluation step first. Let us review the policy evaluation algorithm. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08e94451",
   "metadata": {},
   "source": [
    "<img src=\"./graph/policy_evaluation.png\"  width=\"750\"/>\n",
    "<img src=\"./graph/pe_pseudocode.png\"  width=\"750\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fa136cd",
   "metadata": {},
   "source": [
    "The following function implements the policy evaluation algorithm. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "03ff18f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Elements in state_transactions are quadruples state, action, reward, next_state\n",
    "# action is a quadruple consisting of [idle = 0 / serve = 1, serving position [x,y], destination posotion [x,y]]\n",
    "# V and N are 9*9*20 (3-d) matrices\n",
    "# delta_t corresponds to the serving time, calculated based on the Manhanttan distance\n",
    "time_ = 2 # The last component of state\n",
    "def policy_evaluation(state_transactions, V, N, starting_index, method):\n",
    "    if V is None:\n",
    "        V = np.zeros(np.array(UPPER_LIMITS_BY_DIMENSION) - np.array(LOWER_LIMITS_BY_DIMENSION) + [1,1,1])\n",
    "    if N is None:\n",
    "        N = np.zeros(np.array(UPPER_LIMITS_BY_DIMENSION) - np.array(LOWER_LIMITS_BY_DIMENSION) + [1,1,1])\n",
    "    for t in range(NUMBER_OF_TIME_STEPS, -1, -1):\n",
    "        for state, action, reward, next_state in state_transactions[starting_index:]:\n",
    "            if state[time_] == t:\n",
    "                N[tuple(state)] += 1\n",
    "                delta_t = 1\n",
    "                if action[0] == 1:\n",
    "                    delta_t += manhattan_distance(state[:2], action[1]) + manhattan_distance(action[1], action[2])    \n",
    "                future_value = 0\n",
    "                if next_state[time_] < NUMBER_OF_TIME_STEPS:\n",
    "                    future_value = np.power(DISCOUNT_FACTOR, delta_t) * V[tuple(next_state)]\n",
    "                if method == 'mdp':\n",
    "                    modified_reward = discounted_reward_mdp(DISCOUNT_FACTOR, delta_t ,reward)\n",
    "                elif method == 'myopic':\n",
    "                    modified_reward = reward\n",
    "                V[tuple(state)] += 1./(N[tuple(state)]) * (future_value + modified_reward - V[tuple(state)])\n",
    "    return V, N\n",
    "\n",
    "ratios_of_served_orders = []"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86dce43b",
   "metadata": {},
   "source": [
    "Finally, let us review the order dispatch step. \n",
    "\n",
    "<img src=\"./graph/CD.png\"  width=\"750\"/>\n",
    "<img src=\"./graph/MDP.png\"  width=\"750\"/>\n",
    "\n",
    "The definition of the advantage function is given below.\n",
    "\n",
    "<img src=\"./graph/ad_fun.png\"  width=\"750\"/>\n",
    "\n",
    "The following code implements the entire algorithm when being applied to the toy example. In a first phase it creates a historical dataset that lasts for 500 days (500 episodes) by running the 'distance' method (e.g., the closest-driver policy). Then, with this historical data the value function $V$ gets computed, based on which a new matching algorithm is devised. Next, we generate another 500-day dataset (500 epsidodes) to evaluate the performance of different policies. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e26a93c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "BASE_REWARD_PER_TRIP = 1\n",
    "REWARD_FOR_DISTANCE_PARAMETER = 0\n",
    "\n",
    "def real_time_order_dispatch_algorithm():\n",
    "\n",
    "    NUM_EPISODES = 1000 \n",
    "    BENCHMARK_RUNS = 500 \n",
    "    NUM_INDEPENDENT_RUNS = NUM_EPISODES - BENCHMARK_RUNS \n",
    "\n",
    "    # Consider three settings where the number of drivers equals 25, 50 and 75, respectively. Recall that the total number of orders is given by 100.\n",
    "    number_of_drivers_list = [25,50,75]\n",
    "    # Consider three methods, distance (closest driver policy), myopic policy (gamma=0) and MDP policy\n",
    "    method_list = ['distance', 'myopic', 'mdp']\n",
    "    # Consider two measurements, the completion rate and the average distance between orders and drivers\n",
    "    measurement_keypoints = ['ratio served', 'average distance to driver']\n",
    "\n",
    "    stored_mdp_V_functions = [] \n",
    "    \n",
    "    # Measures the performance for each algorithm\n",
    "    benchmark_data = np.zeros((len(number_of_drivers_list), len(method_list), len(measurement_keypoints),BENCHMARK_RUNS))\n",
    "\n",
    "    for number_of_drivers_ind, number_of_drivers in enumerate(number_of_drivers_list):\n",
    "        for method_ind, method in enumerate(method_list):\n",
    "            transition_data = []\n",
    "            if method in ['mdp', 'myopic']:\n",
    "                ## Initialize the value and the state counter\n",
    "                V, N = policy_evaluation(transition_data, None, None, 0, method)\n",
    "                starting_index = 0\n",
    "\n",
    "            for episode in range(NUM_EPISODES): \n",
    "                \n",
    "                order_driver_distances = []\n",
    "\n",
    "                # Generate 500 episodes as historical data and then 500 episodes to evaluate difference policies\n",
    "                if episode == NUM_INDEPENDENT_RUNS and method in ['mdp', 'myopic']:\n",
    "                    V, N = policy_evaluation(transition_data, V, N, starting_index, method)\n",
    "                    starting_index = len(transition)\n",
    "\n",
    "                destinations = []\n",
    "                for _ in range(NUMBER_OF_ORDERS):\n",
    "                    # destination is drawn uniformly randomly from the grid\n",
    "                    destinations.append(spawn_uniformly_x_y_location())\n",
    "                \n",
    "                # in orders first entry is boolean corresponding to wether it is served.\n",
    "                orders = list(map(list, zip([False] * NUMBER_OF_ORDERS, mixture_gaussian_model.rvs(NUMBER_OF_ORDERS), np.round(waiting_times).astype(int), destinations, range(NUMBER_OF_ORDERS))))\n",
    "                drivers = []\n",
    "                for i in range(number_of_drivers):\n",
    "                    # first entry describes the first time the driver is available again\n",
    "                    # driver's location is drawn uniformly randomly from the grid\n",
    "                    drivers.append([0, spawn_uniformly_x_y_location(), i])\n",
    "                    \n",
    "                for t in range(NUMBER_OF_TIME_STEPS):\n",
    "                    # obtain active orders\n",
    "                    active_orders = [order for order in orders if (order[0] == False) and (order[1][2] <= t) and (order[1][2] + order[2] >= t)]\n",
    "                    available_drivers = [driver for driver in drivers if driver[0] <= t]\n",
    "                    # print(len(active_orders), len(available_drivers)) \n",
    "                    # print(drivers)\n",
    "\n",
    "                    allowed_match = np.ones((len(active_orders), len(available_drivers)), dtype=bool)\n",
    "                    for order_count, active_order in enumerate(active_orders):\n",
    "                        for driver_count, available_driver in enumerate(available_drivers):\n",
    "                            # only consider drivers whose manhattan distance is slower than 2\n",
    "                            if manhattan_distance(available_driver[1], active_order[1][:2]) > MAX_MANHATTAN_DISTANCE:\n",
    "                                allowed_match[order_count, driver_count] = False\n",
    "                    # print(allowed_match)\n",
    "\n",
    "                    # computation of advantage function\n",
    "                    if method in ['mdp', 'myopic']:\n",
    "                        #Could also initialize with - infinity.\n",
    "                        advantage_function = np.zeros((len(active_orders), len(available_drivers))) \n",
    "                        for order_count, active_order in enumerate(active_orders):\n",
    "                            for driver_count, available_driver in enumerate(available_drivers):\n",
    "                                if(allowed_match[order_count, driver_count]):\n",
    "                                    # the pickup time\n",
    "                                    delta_t = 1 + manhattan_distance(available_driver[1], active_order[1][:2]) + manhattan_distance(active_order[1][:2], active_order[3])    \n",
    "                                    reward = BASE_REWARD_PER_TRIP + REWARD_FOR_DISTANCE_PARAMETER  * manhattan_distance(active_order[1][:2], active_order[3])  \n",
    "                                    #If the completion time is later than the last time step, we just stop set the future value to zero\n",
    "                                    future_value = 0.\n",
    "                                    if t + delta_t < NUMBER_OF_TIME_STEPS: \n",
    "                                        discount = DISCOUNT_FACTOR\n",
    "                                        if method == 'myopic':\n",
    "                                            discount = 0.\n",
    "                                        future_value = np.power(discount, delta_t) * V[active_order[3][0],active_order[3][1], t + delta_t]\n",
    "                                    current_value = V[available_driver[1][0], available_driver[1][1], t]\n",
    "                                    modified_reward = reward\n",
    "                                    if method == 'mdp':\n",
    "                                        modified_reward = discounted_reward_mdp(DISCOUNT_FACTOR, delta_t, reward)\n",
    "                                    advantage_function[order_count, driver_count] = future_value - current_value + modified_reward\n",
    "                        \n",
    "                        # plot_sample_histogram(np.array([active_order[1] for active_order in active_orders]), \"Active Orders at time {}\".format(t))\n",
    "                        # plot_sample_histogram(np.array([available_driver[1] for available_driver in available_drivers]), \"Available Drivers at time {}\".format(t))\n",
    "                        \n",
    "                        # print(advantage_function)\n",
    "                        # print(advantage_function.shape)\n",
    "                        \n",
    "                        # Matchs orders to drivers. Note the important subtelty that the function linear_sum_assignment returns a full matching. But we are happy with a partial matching already.\n",
    "\n",
    "                    row_ind = [] \n",
    "                    col_ind = []\n",
    "\n",
    "                    # The initial independent runs should use the 'distance' policy to find the matching.\n",
    "                    # Later runs could either use 'mdp', 'myopic' or 'distance' policy\n",
    "                    if episode >= NUM_INDEPENDENT_RUNS and method in ['mdp','myopic']:\n",
    "                        penalized_advantage_matrix = advantage_function\n",
    "                        for i in range(len(active_orders)):\n",
    "                            for j in range(len(available_drivers)):\n",
    "                                if not allowed_match[i,j]:\n",
    "                                    penalized_advantage_matrix[i,j] = - 100 * NUMBER_OF_ORDERS\n",
    "                        row_ind, col_ind = linear_sum_assignment(-penalized_advantage_matrix)\n",
    "\n",
    "                    else:\n",
    "                        #Use distance matrix to compute assignment\n",
    "                        distance_matrix = -np.ones((len(active_orders), len(available_drivers))) * 100 * NUMBER_OF_ORDERS\n",
    "                        for i in range(len(active_orders)):\n",
    "                            for j in range(len(available_drivers)):\n",
    "                                if allowed_match[i,j]:\n",
    "                                    distance_matrix[i,j] = -manhattan_distance(available_drivers[j][1], active_orders[i][1][:2]) \n",
    "                        row_ind, col_ind = linear_sum_assignment(-distance_matrix) \n",
    "\n",
    "                    matched_order_ind = []\n",
    "                    matched_driver_ind = []\n",
    "\n",
    "                    for i in range(len(row_ind)):\n",
    "                        if row_ind[i] < len(active_orders) and col_ind[i] < len(available_drivers) and allowed_match[row_ind[i],col_ind[i]]:\n",
    "                            matched_order_ind.append(row_ind[i])\n",
    "                            matched_driver_ind.append(col_ind[i])\n",
    "\n",
    "                    # print(f\"Matched orders in iteration {t}\")\n",
    "                    for i in range(len(matched_order_ind)):\n",
    "                        if allowed_match[matched_order_ind[i]][matched_driver_ind[i]]:\n",
    "                            matched_order = active_orders[matched_order_ind[i]]\n",
    "                            matched_driver = available_drivers[matched_driver_ind[i]]\n",
    "                            # if method == 'mdp':\n",
    "                                # print(f'Order {matched_order[-1]} at {matched_order[1][:2]} is matched to driver {matched_driver[-1]} at {matched_driver[1]}')\n",
    "                            matched_order[0] = True\n",
    "\n",
    "                            order_driver_distance = manhattan_distance(matched_driver[1], matched_order[1][:2])\n",
    "\n",
    "                            # continue to run the code only when the assertion is satisfied. Stop and return an error otherwise\n",
    "                            assert(order_driver_distance <= 2)\n",
    "\n",
    "                            order_driver_distances.append(order_driver_distance)\n",
    "\n",
    "                            delta_t = 1 + manhattan_distance(matched_driver[1], matched_order[1][:2]) + manhattan_distance(matched_order[1][:2], matched_order[3])    \n",
    "                            matched_driver[0] = t + delta_t \n",
    "\n",
    "                            #Append to transition data.\n",
    "                            \n",
    "                            reward = BASE_REWARD_PER_TRIP + REWARD_FOR_DISTANCE_PARAMETER  * manhattan_distance(matched_order[1][:2], matched_order[3])  \n",
    "                            \n",
    "                            transition = [[matched_driver[1][0], matched_driver[1][1], t], [1, matched_order[1][:2], matched_order[3]], reward, [matched_order[3][0], matched_order[3][1], t + delta_t]]\n",
    "                            transition_data.append(transition.copy())\n",
    "                            \n",
    "                            matched_driver[1] = matched_order[3]\n",
    "\n",
    "                    # Set transition data for unmatched drivers \n",
    "                    for i, unmatched_driver in enumerate(available_drivers):\n",
    "                        if i not in matched_driver_ind:\n",
    "                            transition = [[unmatched_driver[1][0], unmatched_driver[1][1], t],[0],0,[unmatched_driver[1][0], unmatched_driver[1][1], t + 1]]\n",
    "                            transition_data.append(transition.copy())\n",
    "\n",
    "                if episode >= NUM_INDEPENDENT_RUNS: \n",
    "                    number_of_served_orders = 0\n",
    "                    for i in range(len(orders)):\n",
    "                        number_of_served_orders += orders[i][0]\n",
    "                        \n",
    "                    # calculate the completion rate\n",
    "                    ratio_served = float(number_of_served_orders)/ NUMBER_OF_ORDERS\n",
    "                    benchmark_data[number_of_drivers_ind, method_ind, :,  episode - NUM_INDEPENDENT_RUNS] = [ratio_served, np.mean(np.array(order_driver_distances))]\n",
    "                    if method == 'mdp' and episode == NUM_EPISODES - 1:\n",
    "                        # Used for visualising value functions\n",
    "                        stored_mdp_V_functions.append(V.copy()) \n",
    "\n",
    "    print(benchmark_data) \n",
    "    plot_benchmarks(benchmark_data, number_of_drivers_list, method_list, measurement_keypoints) \n",
    "    plot_value_functions(stored_mdp_V_functions)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5ace222",
   "metadata": {},
   "source": [
    "Here are the plotting functions: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c6a1ea10",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_benchmarks(benchmark_data, number_of_drivers_list, method_list, measurement_keypoints):\n",
    "    \n",
    "    fig, axes = plt.subplots(1, benchmark_data.shape[2]) \n",
    "    benchmark_mean = np.mean(benchmark_data, axis = 3)\n",
    "    benchmark_std = np.std(benchmark_data, axis = 3)\n",
    "\n",
    "    barWidth = 0.25\n",
    "\n",
    "    barColors = ['tab:red', 'tab:green', 'tab:blue']\n",
    "\n",
    "    for idx, ax in enumerate(axes):\n",
    "        data_mean = benchmark_mean[:,:,idx] \n",
    "        data_std = benchmark_std[:,:,idx]\n",
    "        \n",
    "        # The x position of bars\n",
    "        x_pos = []\n",
    "        r1 = np.arange(len(number_of_drivers_list))\n",
    "        for i in range(len(method_list)): \n",
    "            x_pos.append([x + i * barWidth for x in r1]) \n",
    "\n",
    "        for method_idx, method in enumerate(method_list):\n",
    "            ax.bar(x_pos[method_idx], data_mean[:,method_idx], width = barWidth, color = barColors[method_idx], yerr=data_std[:,method_idx], capsize=7, label=method)\n",
    "        # general layout\n",
    "        ax.set_xticks([r + barWidth for r in range(len(number_of_drivers_list))])\n",
    "        ax.set_xticklabels(number_of_drivers_list)\n",
    "        ax.set_title(measurement_keypoints[idx]) \n",
    "\n",
    "    handles, labels = ax.get_legend_handles_labels()\n",
    "    fig.legend(handles, labels, loc='upper center', ncol=len(method_list)) \n",
    "    #Show graphic\n",
    "    plt.show() \n",
    "    \n",
    "def plot_value_functions(value_functions):\n",
    "    time_step = 3\n",
    "    \n",
    "    fig = plt.figure(figsize=(12, 8))\n",
    "\n",
    "    for idx in range(len(value_functions)):\n",
    "        ax = fig.add_subplot(1,len(value_functions),idx+1, projection='3d')\n",
    "        plot_values = value_functions[idx][:,:,time_step]\n",
    "\n",
    "        # print(\"Value function is \", plot_values)\n",
    "\n",
    "        X = np.arange(NUMBER_OF_GRID_TILES_X)\n",
    "        Y = np.arange(NUMBER_OF_GRID_TILES_Y)\n",
    "        \n",
    "        X, Y = np.meshgrid(X,Y)\n",
    "\n",
    "        ax.plot_surface(X, Y, plot_values, cmap=plt.cm.coolwarm, linewidth=1, rstride=1, cstride=1)\n",
    "\n",
    "        ax.set_xlabel(\"X\")\n",
    "        ax.set_ylabel(\"Y\")\n",
    "        ax.set_zlabel(\"Value\")\n",
    "    \n",
    "    plt.suptitle(\"Values at time {}\".format(time_step))\n",
    "    plt.show()    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b221ec3f",
   "metadata": {},
   "source": [
    "Let us run the algorithm. It takes more than 10 minutes to finish running the algorithm. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "bf13fe98",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[[0.5        0.49       0.54       ... 0.46       0.46\n",
      "    0.5       ]\n",
      "   [1.24       1.18367347 1.12962963 ... 1.30434783 1.36956522\n",
      "    1.32      ]]\n",
      "\n",
      "  [[0.43       0.46       0.58       ... 0.53       0.52\n",
      "    0.52      ]\n",
      "   [1.55813953 1.67391304 1.4137931  ... 1.66037736 1.63461538\n",
      "    1.5       ]]\n",
      "\n",
      "  [[0.45       0.45       0.45       ... 0.54       0.52\n",
      "    0.56      ]\n",
      "   [1.46666667 1.75555556 1.6        ... 1.33333333 1.48076923\n",
      "    1.5       ]]]\n",
      "\n",
      "\n",
      " [[[0.76       0.82       0.76       ... 0.77       0.79\n",
      "    0.73      ]\n",
      "   [0.97368421 1.04878049 1.14473684 ... 1.         1.02531646\n",
      "    0.95890411]]\n",
      "\n",
      "  [[0.77       0.74       0.71       ... 0.9        0.8\n",
      "    0.8       ]\n",
      "   [1.63636364 1.54054054 1.61971831 ... 1.67777778 1.6875\n",
      "    1.65      ]]\n",
      "\n",
      "  [[0.71       0.9        0.67       ... 0.75       0.8\n",
      "    0.73      ]\n",
      "   [1.6056338  1.43333333 1.56716418 ... 1.42666667 1.4875\n",
      "    1.67123288]]]\n",
      "\n",
      "\n",
      " [[[0.85       0.85       0.89       ... 0.84       0.89\n",
      "    0.85      ]\n",
      "   [0.81176471 0.98823529 0.8988764  ... 0.83333333 0.92134831\n",
      "    0.71764706]]\n",
      "\n",
      "  [[0.91       0.94       0.92       ... 0.92       0.93\n",
      "    0.99      ]\n",
      "   [1.69230769 1.71276596 1.70652174 ... 1.73913043 1.7311828\n",
      "    1.66666667]]\n",
      "\n",
      "  [[0.97       0.87       0.95       ... 0.94       0.97\n",
      "    0.95      ]\n",
      "   [1.43298969 1.44827586 1.49473684 ... 1.55319149 1.36082474\n",
      "    1.36842105]]]]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAHPCAYAAACBRNrVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABW0klEQVR4nO3de1gUZeM+8HuBZZeDgCjCogiI5zwhpoDn18TwkPXmIS0PiIlp+iqWRmaiWZiWopmK39TVTKTCQ5qpVIqaWB6gLA+vJgavLpmaIshB4Pn94Y/NdXeBlYVh4f5c114XM/PMM88Mu7P3zjwzIxNCCBARERFJxErqBhAREVHdxjBCREREkmIYISIiIkkxjBAREZGkbKRuAJlHcXEx7t+/L3UziIiqnVwuh7W1tdTNoEpgGLFwQghkZWXh9u3bUjeFiEgyLi4u8PDwgEwmk7op9BgYRixcaRBp1KgR7O3t+UEkojpFCIF79+7h+vXrAACVSiVxi+hxMIxYsOLiYm0QadCggdTNISKShJ2dHQDg+vXraNSoEU/ZWCB2YLVgpX1E7O3tJW4JEZG0SveD7DtnmRhGagGemiGiuo77QcvGMEJERESSYhghojpt/PjxePbZZ6VuRp116NAhyGQyXhFYx7EDay10rnWbal1em/PnzFJPnz590KlTJ8TGxsLHxwczZszAjBkzzFJ3XdB+U/tqXd6ZcWeqdXlVZcWKFaipzwv1eePral3elcWDqnV5RKV4ZIRqpBMnTmDSpEkVKuvj44PY2NiqbRDVWs7OznBxcZG6GUR1GsMI1Uhubm68SqiW6dOnD6ZNm4YZM2agfv36cHd3x7p165Cbm4uwsDDUq1cPfn5++OabbyCEQPPmzfHBBx/o1PHrr7/CysoKv//+OwAgIyMDQ4cOhaOjI5ycnDBixAj8+eef2vLR0dHo1KkT4uLi4OXlBXt7ewwfPlznlMCjp2lKSkrw/vvvo3nz5lAoFGjatCnefffdKt02lsqU/2mpvXv3omXLlrCzs0Pfvn1x5coVnTrVajVcXFywc+dOtGzZEkqlEv3790dmZmY1rx1VJ4YRkkRubi7Gjh0LR0dHqFQqfPjhhzrTHz3aER0djaZNm0KhUMDT0xPTp08H8GBn+Mcff2DmzJmQyWTaHvU3b97EqFGj0KRJE9jb26N9+/aIj4/XWUafPn0wffp0zJ49G66urvDw8EB0dLROmdu3b2PSpElwd3eHUqlEu3btsGfPHu30Y8eOoVevXrCzs4OXlxemT5+O3NxcM26p2mXTpk1o2LAhfvrpJ0ybNg2vvPIKhg8fjuDgYJw+fRoDBgzAmDFjkJeXhwkTJmDjxo0682/YsAE9e/aEn58fhBB49tlncevWLSQnJyMpKQm///47Ro4cqTPPpUuX8Pnnn2P37t3Yt28f0tLSMHXqVKNtjIqKwvvvv4958+bh7Nmz2Lp1K9zd3atke9QGFf2f3rt3D5mZmfj3v/+NgQMHIi0tDRMnTsQbb7yhV+e9e/fw7rvvYtOmTfjhhx+QnZ2NF154QYK1o+rCMEKSeP3113Hw4EHs2LEDBw4cwKFDh3Dq1CmDZb/88kssX74ccXFxuHjxInbu3In27R/0j9i+fTuaNGmChQsXQqPRQKPRAADy8/MREBCAPXv24Ndff8WkSZMwZswY/Pjjjzp1b9q0CQ4ODvjxxx+xZMkSLFy4EElJSQAe/EIODQ3FsWPHsGXLFpw9exaLFy/W3lDpzJkzGDBgAP7973/jl19+QUJCAo4ePYpXX321qjabxevYsSPeeusttGjRAlFRUbCzs0PDhg3x8ssvo0WLFnj77bdx8+ZN/PLLLwgLC8OFCxfw008/AXhw/4gtW7ZgwoQJAIBvv/0Wv/zyC7Zu3YqAgAB069YNn376KZKTk3HixAntMvPz87Fp0yZ06tQJvXr1wkcffYRt27YhKytLr313797FihUrsGTJEowbNw5+fn7o0aMHJk6cWD0byAKZ8j9ds2YNmjVrhuXLl6NVq1Z48cUXMX78eL0679+/j1WrViEoKAgBAQHYtGkTjh07pn0vUO3DDqxU7XJycrB+/Xps3rwZ/fv3B/AgFDRp0sRg+YyMDHh4eOCpp56CXC5H06ZN0bVrVwCAq6srrK2tUa9ePXh4eGjnady4MV577TXt8LRp07Bv3z588cUX6Natm3Z8hw4dMH/+fABAixYtsGrVKnz33Xfo378/vv32W/z00084d+4cWrZsCQBo1qyZdt6lS5di9OjR2k62LVq0wMqVK9G7d2+sWbMGSqXSDFurdunQoYP2b2trazRo0EAbLAFoj0Bcv34dgYGBGDRoEDZs2ICuXbtiz549yM/Px/DhwwEA586dg5eXF7y8vLTzt23bFi4uLjh37hyefPJJAEDTpk113ltBQUEoKSnBhQsXdN4zpXUWFBSgX79+5l/5WsqU/+m5c+cQGBioc0+QoKAgvTptbGzQpUsX7XDr1q21/9fSzz7VLjwyQtXu999/R2Fhoc5OyNXVFa1atTJYfvjw4cjLy0OzZs3w8ssvY8eOHSgqKipzGcXFxXj33XfRoUMHNGjQAI6Ojjhw4AAyMjJ0yj28IwUePNei9BkXaWlpaNKkiTaIPOrUqVNQq9VwdHTUvgYMGICSkhKkp6eXux3qIrlcrjMsk8l0xpV+SZWUlAAAJk6ciG3btiEvLw8bN27EyJEjtX2JhBAGb3RlbPyjyzBUpvS24lRxpvxPTblqydD/hzc2q70YRqjamXoZpZeXFy5cuICPP/4YdnZ2mDJlCnr16lXmbZ8//PBDLF++HLNnz8b333+PtLQ0DBgwAIWFhTrlDO1IS78Iy/tiKikpQUREBNLS0rSvn3/+GRcvXoSfn59J60iGDRw4EA4ODlizZg2++eYb7Ska4MFRkIyMDJ2OjWfPnsWdO3fQps0/l7dnZGTg2rVr2uGUlBRYWVkZDJktWrSAnZ0dvvvuuypao7qtbdu2OH78uM64R4cBoKioCCdPntQOX7hwAbdv30br1q2rvI0kDYYRqnbNmzeHXC7X2Qn9/fff+O9//2t0Hjs7OzzzzDNYuXIlDh06hJSUFJw58+A+F7a2tiguLtYpf+TIEQwdOhQvvfQSOnbsiGbNmuHixYsmtbNDhw743//+Z7RdnTt3xm+//YbmzZvrvWxtbU1aFhlmbW2N8ePHIyoqCs2bN9c5mvbUU0+hQ4cOePHFF3H69Gn89NNPGDt2LHr37q1ziF+pVGLcuHH4+eefceTIEUyfPh0jRozQO0VTWnbOnDmYPXs2Nm/ejN9//x3Hjx/H+vXrq2V9a7vJkyfj999/R2RkJC5cuICtW7dCrVbrlZPL5Zg2bRp+/PFHnD59GmFhYQgMDOQpmlqMYYSqnaOjI8LDw/H666/ju+++w6+//orx48fDysrw21GtVmP9+vX49ddfcfnyZXz66aews7ODt7c3gAdX3hw+fBhXr17FjRs3ADwIPElJSTh27BjOnTuHiIgIgx0Wy9K7d2/06tULzz//PJKSkpCeno5vvvkG+/btAwDMmTMHKSkpmDp1KtLS0nDx4kV89dVXmDZtWiW2Dj0qPDwchYWFOkdFgAdHsXbu3In69eujV69eeOqpp9CsWTMkJCTolGvevLn2Co6QkBC0a9cOq1evNrq8efPmYdasWXj77bfRpk0bjBw5UnvqjiqnadOmSExMxO7du9GxY0esXbsW7733nl45e3t7zJkzB6NHj0ZQUBDs7Oywbds2CVpM1UaQxcrLyxNnz54VeXl5UjfFZHfv3hUvvfSSsLe3F+7u7mLJkiWid+/e4j//+Y8QQghvb2+xfPlyIYQQO3bsEN26dRNOTk7CwcFBBAYGim+//VZbV0pKiujQoYNQKBSi9C198+ZNMXToUOHo6CgaNWok3nrrLTF27FgxdOhQ7XwPL6/U0KFDxbhx47TDN2/eFGFhYaJBgwZCqVSKdu3aiT179min//TTT6J///7C0dFRODg4iA4dOoh3333XrNuqrjt69KiwsbERWVlZJs87f/580bFjR/M3iqrMxo0bhbOzs8nzWfL+kISQCVFD74NM5crPz0d6ejp8fX155QbVOgUFBcjMzMSkSZOgUqnw2WefmVxHdHQ0du7cibS0NPM3kKqEWq3GjBkzTH5WDfeHlo2naYioRoqPj0erVq1w584dLFmyROrmEFEV4pERC8ZfAkRED3B/aNl4ZISIiIgkxTBSC/DgFhHVddwPWjaGEQtWesOue/fuSdwSIiJple4HH72RIVkGPpvGgllbW8PFxUV7DwR7e3veLpmI6hQhBO7du4fr16/DxcVF+yBLsizswGrhhBDIysoy+TI4IqLaxMXFBR4eHvxBZqEYRmqJ4uLiMp/VQkRUW8nlch4RsXAMI0RERCQpdmAlIiIiSTGMEBERkaQYRoiIiEhSDCNEREQkKYYRIiIikhTDCBEREUmKYaSOOHv2LKKjo3HlyhW9aePHj4ePj0+1t8lScPsQPSCTyRAdHa0dVqvVkMlkBvcrZXnvvfewc+dOs7ZNStW9Po/+H8oSHR1tETeCYxipI86ePYsFCxYY3GnMmzcPO3bsqP5GEZFFGzRoEFJSUqBSqUyaj2Gk+kycOBEpKSlSN6NcfDaNhbp37x7s7e3NUpefn59Z6qku5lx3IqkUFxejqKgICoVC6qY8Njc3N7i5uUndDDKgdD/ZpEkTNGnSRLLlVxSPjFiA0sNsp0+fxrBhw1C/fn1tgDh58iReeOEF+Pj4wM7ODj4+Phg1ahT++OMP7fxqtRrDhw8HAPTt2xcymQwymQxqtRqA4dMQ+fn5iIqKgq+vL2xtbdG4cWNMnTq1Qs/AuXz5Ml544QV4enpCoVDA3d0d/fr1Q1pamk65hIQEBAUFwcHBAY6OjhgwYABSU1N1yowfPx6Ojo44c+YMQkJCUK9ePfTr1w8zZsyAg4MDsrOz9ZY/cuRIuLu769wevyLLKt1WrVq1gkKhQJs2bbB58+Zy15csx6VLlxAWFoYWLVrA3t4ejRs3xpAhQ3DmzBltmb/++gu2traYN2+e3vznz5+HTCbDypUrteOysrIQERGBJk2awNbWFr6+vliwYAGKioq0Za5cuQKZTIYlS5Zg0aJF8PX1hUKhwMGDB5Gfn49Zs2ahU6dOcHZ2hqurK4KCgrBr1y695d++fRvh4eFwdXWFo6MjBg0ahMuXLxs8bH/x4kWMHj0ajRo10r6fP/744wptp+zsbLz88sto0KABHB0d8fTTT+O///2vXjlDp2lSU1MxePBg7XI9PT0xaNAg/O9//wPw4BRDbm4uNm3apN0X9enTR7vtp0yZgrZt28LR0RGNGjXCv/71Lxw5ckRnuaXb84MPPsCyZcvg6+sLR0dHBAUF4fjx43rt/PHHHzFkyBA0aNAASqUSfn5+mDFjhlm2V1nrAwC//vorhg4divr160OpVKJTp07YtGlTufUCFf8/lPUd8ehpmmeffRbe3t4oKSnRq6dbt27o3LmzdlgIgdWrV6NTp06ws7ND/fr1MWzYMFy+fFlnvj59+qBdu3Y4fPgwgoODYW9vjwkTJlRoHR9eGNVw8+fPFwCEt7e3mDNnjkhKShI7d+4UQgjxxRdfiLffflvs2LFDJCcni23btonevXsLNzc38ddffwkhhLh+/bp47733BADx8ccfi5SUFJGSkiKuX78uhBBi3LhxwtvbW7u8kpISMWDAAGFjYyPmzZsnDhw4ID744APh4OAg/P39RX5+fpntbdWqlWjevLn49NNPRXJyskhMTBSzZs0SBw8e1JZ59913hUwmExMmTBB79uwR27dvF0FBQcLBwUH89ttv2nLjxo0Tcrlc+Pj4iJiYGPHdd9+J/fv3i59//lkAEP/3f/+ns+y///5bKBQKERkZafKyNm7cKACIoUOHit27d4stW7aI5s2bCy8vL53tQ5YrOTlZzJo1S3z55ZciOTlZ7NixQzz77LPCzs5OnD9/XlvuueeeE15eXqK4uFhn/tmzZwtbW1tx48YNIYQQGo1G+/6Ii4sT3377rXjnnXeEQqEQ48eP186Xnp4uAIjGjRuLvn37ii+//FIcOHBApKeni9u3b4vx48eLTz/9VHz//fdi37594rXXXhNWVlZi06ZN2jqKi4tFjx49hFKpFIsXLxYHDhwQCxYsEC1atBAAxPz587Vlf/vtN+Hs7Czat28vNm/eLA4cOCBmzZolrKysRHR0dJnbqKSkRPTt21coFArx7rvvigMHDoj58+eLZs2a6S2n9DOTnp4uhBAiJydHNGjQQHTp0kV8/vnnIjk5WSQkJIjJkyeLs2fPCiGESElJEXZ2dmLgwIHafVHp5/D8+fPilVdeEdu2bROHDh0Se/bsEeHh4cLKykpn/1G6PX18fMTTTz8tdu7cKXbu3Cnat28v6tevL27fvq0tu2/fPiGXy0WHDh2EWq0W33//vdiwYYN44YUXzLK9ylufevXqCT8/P7F582bx9ddfi1GjRgkA4v333zfb/6Gs74jSaaV27dolAIikpCSd5Z07d04AECtXrtSOe/nll4VcLhezZs0S+/btE1u3bhWtW7cW7u7uIisrS1uud+/ewtXVVXh5eYmPPvpIHDx4UCQnJ5e5fo9iGLEApW+mt99+u9yyRUVFIicnRzg4OIgVK1Zox3/xxRcCgM4HutSjYWTfvn0CgFiyZIlOuYSEBAFArFu3zujyb9y4IQCI2NhYo2UyMjKEjY2NmDZtms74u3fvCg8PDzFixAidtgEQGzZs0Kunc+fOIjg4WGfc6tWrBQBx5swZk5ZVXFwsPD09RefOnUVJSYm23JUrV4RcLmcYqaWKiopEYWGhaNGihZg5c6Z2/FdffSUAiAMHDuiU9fT0FM8//7x2XEREhHB0dBR//PGHTr0ffPCBAKD9Uir98vTz8xOFhYXltun+/fsiPDxc+Pv7a8d//fXXAoBYs2aNTvmYmBi9L6cBAwaIJk2aiDt37uiUffXVV4VSqRS3bt0yuvxvvvlGANDZfwjxINSXF0ZOnjwpAGi/CI1xcHAQ48aNK7OMEP9si379+onnnntOO750e7Zv314UFRVpx//0008CgIiPj9eO8/PzE35+fiIvL8/ociqzvcpanxdeeEEoFAqRkZGhMz40NFTY29vrhKZHmfJ/KOs74tEwcv/+feHu7i5Gjx6tU+7RoJ2SkiIAiA8//FCnXGZmprCzsxOzZ8/Wjuvdu7cAIL777juj61MenqaxIM8//7zeuJycHMyZMwfNmzeHjY0NbGxs4OjoiNzcXJw7d+6xlvP9998DeHCK5GHDhw+Hg4MDvvvuO6Pzurq6ws/PD0uXLsWyZcuQmpqqdzhw//79KCoqwtixY1FUVKR9KZVK9O7dG4cOHdKr19C6h4WF4dixY7hw4YJ23MaNG/Hkk0+iXbt2Ji3rwoULuHbtGkaPHq1zSNPb2xvBwcFlbi+yHEVFRXjvvffQtm1b2NrawsbGBra2trh48aLO5yU0NBQeHh7YuHGjdtz+/ftx7do1ncPPe/bsQd++feHp6anz/goNDQUAJCcn6yz/mWeegVwu12vXF198ge7du8PR0RE2NjaQy+VYv369TptK6xoxYoTOvKNGjdIZzs/Px3fffYfnnnsO9vb2Ou0aOHAg8vPzDZ7KKHXw4EEAwIsvvqgzfvTo0UbnKdW8eXPUr18fc+bMwdq1a3H27Nly53nU2rVr0blzZyiVSu22+O677wzuzwYNGqTztN4OHToAgPY09X//+1/8/vvvCA8Ph1KpNLi8ym6vsnz//ffo168fvLy8dMaPHz8e9+7dK7Nj6eP8HwztJx9lY2ODl156Cdu3b8edO3cAPOi/9Omnn2Lo0KFo0KABgAfvbZlMhpdeeklnm3h4eKBjx456++n69evjX//6V7nLN4ZhxIIY6rE+evRorFq1ChMnTsT+/fvx008/4cSJE3Bzc0NeXt5jLefmzZuwsbHR65gmk8ng4eGBmzdvGp1XJpPhu+++w4ABA7BkyRJ07twZbm5umD59Ou7evQsA+PPPPwEATz75JORyuc4rISEBN27c0KnT3t4eTk5Oest68cUXoVAotH1fzp49ixMnTiAsLExbpqLLKl0nDw8PveUYGkeWKTIyEvPmzcOzzz6L3bt348cff8SJEyfQsWNHnc+LjY0NxowZgx07dmj7SanVaqhUKgwYMEBb7s8//8Tu3bv13ltPPPEEAOi9lw19hrdv344RI0agcePG2LJlC1JSUnDixAlMmDAB+fn52nKln0tXV1ed+d3d3XWGb968iaKiInz00Ud67Ro4cKDBdj06v42NjfZLqVRFPgfOzs5ITk5Gp06d8Oabb+KJJ56Ap6cn5s+fr9OHy5hly5bhlVdeQbdu3ZCYmIjjx4/jxIkTePrppw3uzx5tY2ln4NKyf/31FwCU2YGzsturLDdv3jT4P/f09NROL2teU/8PFb2qqfS9tW3bNgAPgrZGo9Hbdwoh4O7urrddjh8/XqH3til4NY0FefRa8Tt37mDPnj2YP38+3njjDe34goIC3Lp167GX06BBAxQVFeGvv/7SCSRCCGRlZeHJJ58sc35vb2+sX78ewINfJp9//jmio6NRWFiItWvXomHDhgCAL7/8Et7e3uW2x9g18vXr18fQoUOxefNmLFq0CBs3boRSqdT5pVjRZZV+4LOysvSmGRpHlmnLli0YO3Ys3nvvPZ3xN27cgIuLi864sLAwLF26FNu2bcPIkSPx1VdfYcaMGTq/xBs2bIgOHTrg3XffNbi80i+dUobey1u2bIGvry8SEhJ0phcUFOiUK/1c3rp1SyeQPPr+rF+/PqytrTFmzBhMnTrVYLt8fX0Njn94OTdv3tT5Iqzo56B9+/bYtm0bhBD45ZdfoFarsXDhQtjZ2enspwzZsmUL+vTpgzVr1uiML/0hY6rS/Vdp51lDKru9ytKgQQNoNBq98deuXQPwz/7J2Lym/h8qej+Rtm3bomvXrti4cSMiIiKwceNGeHp6IiQkRFumYcOGkMlkOHLkiMErvh4dV9l7mfDIiAWTyWQQQui9KT755BMUFxfrjHv0F0NZ+vXrB+DBjuFhiYmJyM3N1U6viJYtW+Ktt95C+/btcfr0aQDAgAEDYGNjg99//x1dunQx+KqosLAwXLt2DXv37sWWLVvw3HPP6XypVHRZrVq1gkqlQnx8PIQQ2vn/+OMPHDt2rMLtoZpNJpPpfV6+/vprXL16Va9smzZt0K1bN2zcuBFbt25FQUGBzi9HABg8eDB+/fVX+Pn5GXxvPRpGjLXJ1tZWZ2eelZWldzVN7969ATy4Muxhpb9uS9nb26Nv375ITU1Fhw4dDLbr0V/bD+vbty8A4LPPPtMZv3Xr1nLX5dH16tixI5YvXw4XFxft5x94sD8ytC8y9P/55ZdfHvs+GS1btoSfnx82bNigF+5KVXZ7lbU+/fr1w/fff68NH6U2b94Me3t7BAYGGq3TXP8HY8LCwvDjjz/i6NGj2L17N8aNG6cTtAcPHgwhBK5evWpwm7Rv394s7SjFIyMWzMnJCb169cLSpUvRsGFD+Pj4IDk5GevXr9f7lVfah2LdunWoV68elEolfH19DX7I+vfvjwEDBmDOnDnIzs5G9+7d8csvv2D+/Pnw9/fHmDFjjLbpl19+wauvvorhw4ejRYsWsLW1xffff49ffvlF+6vIx8cHCxcuxNy5c3H58mU8/fTTqF+/Pv7880/89NNPcHBwwIIFCyq0DUJCQtCkSRNMmTIFWVlZel8WFV2WlZUV3nnnHUycOBHPPfccXn75Zdy+fRvR0dE8TVOLDB48GGq1Gq1bt0aHDh1w6tQpLF261Ohh/AkTJiAiIgLXrl1DcHAwWrVqpTN94cKFSEpKQnBwMKZPn45WrVohPz8fV65cwd69e7F27dpy7/EwePBgbN++HVOmTMGwYcOQmZmJd955ByqVChcvXtSWe/rpp9G9e3fMmjUL2dnZCAgIQEpKivbycyurf35brlixAj169EDPnj3xyiuvwMfHB3fv3sWlS5ewe/dubb8wQ0JCQtCrVy/Mnj0bubm56NKlC3744Qd8+umn5W7fPXv2YPXq1Xj22WfRrFkzCCGwfft23L59G/3799eWa9++PQ4dOoTdu3dDpVKhXr16aNWqFQYPHox33nkH8+fPR+/evXHhwgUsXLgQvr6+OpdKm+Ljjz/GkCFDEBgYiJkzZ6Jp06bIyMjA/v37tV/0ldleZa3P/Pnztf2K3n77bbi6uuKzzz7D119/jSVLlsDZ2dlonZX5P1TEqFGjEBkZiVGjRqGgoECvj2D37t0xadIkhIWF4eTJk+jVqxccHByg0Whw9OhRtG/fHq+88opZ2gKAl/ZagtLe0KWX6j7sf//7n3j++edF/fr1Rb169cTTTz8tfv31V+Ht7a3Xuzs2Nlb4+voKa2trAUBs3LhRCKF/NY0QQuTl5Yk5c+YIb29vIZfLhUqlEq+88or4+++/y2zrn3/+KcaPHy9at24tHBwchKOjo+jQoYNYvny5Tq93IYTYuXOn6Nu3r3BychIKhUJ4e3uLYcOGiW+//VZbZty4ccLBwaHMZb755psCgMFLMU1ZlhBCfPLJJ6JFixbC1tZWtGzZUmzYsMHg9iHL9Pfff4vw8HDRqFEjYW9vL3r06CGOHDkievfuLXr37q1X/s6dO8LOzs7gZeSl/vrrLzF9+nTh6+sr5HK5cHV1FQEBAWLu3LkiJydHCPHP1R9Lly41WMfixYuFj4+PUCgUok2bNuL//u//9K6CEEKIW7duibCwMOHi4iLs7e1F//79xfHjxw1edZGeni4mTJggGjduLORyuXBzcxPBwcFi0aJF5W6n27dviwkTJugs5/z58+VeTXP+/HkxatQo4efnJ+zs7ISzs7Po2rWrUKvVOvWnpaWJ7t27C3t7ewFAu+0LCgrEa6+9Jho3biyUSqXo3Lmz2Llzp95nsKzt+WgbhXhwZUhoaKhwdnYWCoVC+Pn56Vw9VdntZWx9hBDizJkzYsiQIcLZ2VnY2tqKjh07ave95ano/6Gs7whD76NSo0ePFgBE9+7djbZhw4YNolu3bsLBwUHY2dkJPz8/MXbsWHHy5Eltmd69e4snnniiQutkjEyIh45JExGRRdm6dStefPFF/PDDD7zyiywWwwgRkYWIj4/H1atX0b59e1hZWeH48eNYunQp/P399S4jJrIk7DNCRGQh6tWrh23btmHRokXIzc2FSqXC+PHjsWjRIqmbRlQpPDJCREREkuKlvURERCQphhEiIiKSFMMIERERScoiOrCWlJTg2rVrqFevXqVvOUtEphNC4O7du/D09NS5uVZNxv0GkfQquu+wiDBy7do1vaceElH1y8zMLPeOojUF9xtENUd5+w6LCCP16tUD8GBlDD29lYiqVnZ2Nry8vLSfRUvA/QaR9Cq677CIMFJ6iNXJyYk7FSIJWdLpDu43iGqO8vYdlnHyl4iIiGothhEiIiKSFMMIERERSYphhIiIiCTFMEJERESSYhghIiIiSTGMEBERkaQYRoiIiEhSJoeRw4cPY8iQIfD09IRMJsPOnTvLnSc5ORkBAQFQKpVo1qwZ1q5d+zhtJSIiolrI5DCSm5uLjh07YtWqVRUqn56ejoEDB6Jnz55ITU3Fm2++ienTpyMxMdHkxhIREVHtY/Lt4ENDQxEaGlrh8mvXrkXTpk0RGxsLAGjTpg1OnjyJDz74AM8//7ypiyciIqJapsr7jKSkpCAkJERn3IABA3Dy5Encv3/f4DwFBQXIzs7WeREREVHtVOVhJCsrC+7u7jrj3N3dUVRUhBs3bhicJyYmBs7OztoXHwNORERUe1XLU3sffVqfEMLg+FJRUVGIjIzUDpc+gpiIHtBoNNBoNGarT6VSQaVSma0+IjKfuvB5r/Iw4uHhgaysLJ1x169fh42NDRo0aGBwHoVCAYVCUdVNI7JYcXFxWLBggdnqmz9/PqKjo81WHxGZT134vFd5GAkKCsLu3bt1xh04cABdunSBXC6v6sUT1Rjm/HUTFBSEffv2wc3NzeD0vLw89OjRAwBw9OhR2NnZlVlfTfuVRET/iIiIwDPPPGN0em34vJscRnJycnDp0iXtcHp6OtLS0uDq6oqmTZsiKioKV69exebNmwEAkydPxqpVqxAZGYmXX34ZKSkpWL9+PeLj4823FkQWoDp/3eTm5mr/7tSpExwcHMy2XCKqXuWdVqkNn3eTw8jJkyfRt29f7XBp345x48ZBrVZDo9EgIyNDO93X1xd79+7FzJkz8fHHH8PT0xMrV67kZb1U59TWXzeHDx/G0qVLcerUKWg0GuzYsQPPPvus0fLjx4/Hpk2b9Ma3bdsWv/32GwBArVYjLCxMr0xeXh6USqXZ2k5ENYPJYaRPnz7aDqiGqNVqvXG9e/fG6dOnTV0UUa1SW3/dlN4IMSwsrEI/MlasWIHFixdrh4uKitCxY0cMHz5cp5yTkxMuXLigM45BhKh2qparaYio9jL1Roill+yX2rlzJ/7++2+9IyEymQweHh5maycR1Vx8UB4RSWr9+vV46qmn4O3trTM+JycH3t7eaNKkCQYPHozU1NQy6+HNEoksF8MIEUlGo9Hgm2++wcSJE3XGt27dGmq1Gl999RXi4+OhVCrRvXt3XLx40WhdvFkikeViGCEiyajVari4uOh1eA0MDMRLL72Ejh07omfPnvj888/RsmVLfPTRR0brioqKwp07d7SvzMzMKm49EZkL+4wQkSSEENiwYQPGjBkDW1vbMstaWVnhySefLPPICG+WSGS5GEaISBLJycm4dOkSwsPDyy0rhEBaWhrat29fDS2j6lAXbnFOFccwQkSVYuqNEEutX78e3bp1Q7t27fTqXLBgAQIDA9GiRQtkZ2dj5cqVSEtLw8cff1zl60PVoy7c4txc2m8qO4SXFJRo/+76WVdYKYz3wDgz7ozZ2mVODCNEVCmm3ggRAO7cuYPExESsWLHCYJ23b9/GpEmTkJWVBWdnZ/j7++Pw4cPo2rVr1a0IVavaehNAejwMI0RUKY9zI0RnZ2fcu3fP6DzLly/H8uXLzdE8qqFq600A6fHwahoiIiKSFMMIERERSYqnaYgskM8bX5c5vaQwX/t3m3n7YGVr/JkuVxYPMlu7iIgeB8MIEZEZ8ZJVItMxjBBVo7Iu0TPl8jxgcRnTSEq8ZJXIdAwjRGUw96/c+7fvQ+4iN1t9VPPwklUi0zGMEJXB3L9y3Ya6wf05d7PVRzUPL1klMh3DCFEZzP0rd/SR0WZtHxFRbcAwQlQGc//KlZ/hKRoiMs392/dRdLvI6PSS+//0N8vLyIOV3Hh/s9OnT9fITtEMI0REJAlzdeiuqc9bMZdbB2/hr11/Vahs+rvpZU4PiA6okZ2iGUaIiIhqMNe+rnDydzJLXZ8P+bzGHRUBGEaIiIhqNLmL3GxX4XXu3Nks9ZgbbwdPREREkmIYISIiIkkxjBAREZGkGEaIiIhIUgwjREREJCleTUNkgYpybqE455bR6eJ+ofbvwj8vQya3NVq2pt4EiYjqDoYRIguUk/YN7vwQX6Gyf26dXeb0gE18MiwRSYthhKiaaDQa5F3JMzrdlFs623q2htuIhbC2q/yNkL6e3pNHRYhIUgwjRNUkLi4Ovy/4vUJly7ulMzAfzt1HwaXHi5VuV029CRIR1R0MI0TVJCIiAltkW8xSV276NFg7upqlLjKvsp63AvCZK6XMeaSQ/Z4sH8MIUTVRqVSw87EzS11Fec3NUg+RVMx5pLCmPvyNKo5hhIiIqp05jxTW1Ie/UcUxjBARUbUz55FC9nuyfAwjROU417qN0Wn3Sv45r33evzPsrcq5j2AUP3JERI/iHViJiIhIUvyZRkREVAfcv30fp0+fNlt95ryCiWGEiKgGqslfHGSZbh28hYAZAWarz5xXMDGMEBHVQDX5i6Om0Wg00Gg0ZquvtgY3176u2Pf2PqPT8/Ly0KNHDwDA0aNHYWdXdgdjc24jhhEiohqoJn9x1DRxcXFYsGCB2eqrrcFN7iIv88qj3Nxc7d+dOnWCg4NDdTQLAMMIEVGNVJO/OGqaiIgIPPPMM0anM7jVfAwjRERk0co7rcLgVvPx0l4iIiKSFMMIERERSYqnaajGYI94IqK6iWGEagz2iKfa4P7t+yi6XWR0esn9fx4hkJeRByu58QPUp0+fZqimOoFhhGoM9oin2uDWwVv4a9dfFSqb/m56mdMDogMYqqlOYBihGoM94qk2cO3rCid/J7PU9fmQzxmqqU5gB1YiqpTDhw9jyJAh8PT0hEwmw86dO8ssf+jQIchkMr3X+fPndcolJiaibdu2UCgUaNu2LXbs2FGFa2E+chc57HzszPLq3LkzwwjVCTwyQpXGjqd1W25uLjp27IiwsDA8//zzFZ7vwoULcHL65wiCm5ub9u+UlBSMHDkS77zzDp577jns2LEDI0aMwNGjR9GtWzeztp+IpMcwQpXGjqd1W2hoKEJDQ02er1GjRnBxcTE4LTY2Fv3790dUVBQAICoqCsnJyYiNjUV8fLzBeQoKClBQUKAdzs7ONrlNRCQNhhGqNHY8pcfh7++P/Px8tG3bFm+99Rb69u2rnZaSkoKZM2fqlB8wYABiY2ON1hcTE2PWUExE1YdhhCqNHU/JFCqVCuvWrUNAQAAKCgrw6aefol+/fjh06BB69eoFAMjKyoK7u7vOfO7u7sjKyjJab1RUFCIjI7XD2dnZ8PLyqpqVICKzYhghKoNGo8HZ/Hyj0/NL/rlnxPn8fCityu4Tfv+2AnIXudnaZ4latWqFVq1aaYeDgoKQmZmJDz74QBtGAEAmk+nMJ4TQG/cwhUIBhUJh/gYTUZVjGCEqQ1xcHBb8caVCZV/KzCi3jNtBN7g/515uubomMDAQW7Zs0Q57eHjoHQW5fv263tESIjKNzxtfG51WUvjPD6828/bBylZZZl1XFg8yW7sYRojKEBERgfbqTWarb25f/nI3JDU1VedUX1BQEJKSknT6jRw4cADBwcFSNI+IqhjDCFEZVCoV2irL/nVgCrlL7fvI5eTk4NKlS9rh9PR0pKWlwdXVFU2bNkVUVBSuXr2KzZs3A3hwpYyPjw+eeOIJFBYWYsuWLUhMTERiYqK2jv/85z/o1asX3n//fQwdOhS7du3Ct99+i6NHj1b7+lHNV9avfcC0X/zm/LVPFVf79oxEVK1OnjypcyVMaSfScePGQa1WQ6PRICPjn1NYhYWFeO2113D16lXY2dnhiSeewNdff42BAwdqywQHB2Pbtm146623MG/ePPj5+SEhIaHO3WOkph5SJzI3hhEiqpQ+ffpACGF0ulqt1hmePXs2Zs+eXW69w4YNw7BhwyrbPCKyALwdPBEREUnqscLI6tWr4evrC6VSiYCAABw5cqTM8p999hk6duwIe3t7qFQqhIWF4ebNm4/VYCIiIqpdTA4jCQkJmDFjBubOnYvU1FT07NkToaGhOueEH3b06FGMHTsW4eHh+O233/DFF1/gxIkTmDhxYqUbT0RERJbP5DCybNkyhIeHY+LEiWjTpg1iY2Ph5eWFNWvWGCx//Phx+Pj4YPr06fD19UWPHj0QERGBkydPVrrxREREZPlM6sBaWFiIU6dO4Y033tAZHxISgmPHjhmcJzg4GHPnzsXevXsRGhqK69ev48svv8SgQcZ7dvOBV1WPT9olIqKawqQwcuPGDRQXF5v0zIjg4GB89tlnGDlyJPLz81FUVIRnnnkGH330kdHl8IFXVY9P2iUioprisS7tNeWZEWfPnsX06dPx9ttvY8CAAdBoNHj99dcxefJkrF+/3uA8fOBV1eOTdomIqKYwKYw0bNgQ1tbWJj0zIiYmBt27d8frr78OAOjQoQMcHBzQs2dPLFq0yOCXGB94VfVq6pN2eZMnIqK6x6QOrLa2tggICEBSUpLO+KSkJKPPjLh37x6sHnmSqbW1NQCUeaMkIiIiqhtMvpomMjISn3zyCTZs2IBz585h5syZyMjIwOTJkwE8OMUyduxYbfkhQ4Zg+/btWLNmDS5fvowffvgB06dPR9euXeHp6Wm+NSEiIiKLZHKfkZEjR+LmzZtYuHAhNBoN2rVrh71798Lb2xsA9J5DMX78eNy9exerVq3CrFmz4OLign/96194//33zbcWREREZLEeqwPrlClTMGXKFIPTHn0OBQBMmzYN06ZNe5xFkQVov6l9mdNLCkq0f3f9rCusFGUdkFtsplYREdHD7t++j4KsS0ani/uF2r8L/7wMmdy2zPo0Go3ZLl7gg/KIiIjqgFsHb+GvXTMqVPbPreU/zDLO52+z3dKBYYSIiCxaUc4tFOfcMjrdlF/8p0+frrU3cXTt6wprl7lmqy8iYoTZ6mIYISIii5aT9g3u/BBfobLl/eIP2FR7b+Iod5FD4dHcbPWZM7AxjBARkUVz7BQKu+bdzFLX19N71sqjIjUdwwgREVk0G0dX2Di6mqWuzp07m6UeMg3DCBFRDVSTr3wgMjeGESKiGqgmX/lAZG4MI0RENVBNvvKByNwYRoiIaqCafOUDkbmZ/GwaIiIiInNiGCEiIiJJMYwQERGRpNhnhIjqPI1GA41GY5a68q7kwcbFBnIXuVnqI6oLGEaIqM6Li4vDggULzFaf21A3uD/nbrb6iGo7hpE67FzrNkan3Ssp0f593r8z7K3KOKMXZZ63EW/yRFKJiIjAM888Y3R6Xl4eevToAQA4evQo7OzsjJYdsXsEbFy4ayUyBT8xVGPwJk8klfKe0pqbm6v9u1OnTnBwcDBa1u6M8aBCRIYxjFCNwZs8ERHVTQwjVGn3b99H0e0io9NL7v9zyicvIw9W8rIv4rI200OveIqGiMgyMIxQpT04vfJXhcqmv5teTokZcO4+Ci49Xqx8w4iIyCIwjFClufZ1hZO/k1nqyk2fBmszPQqciIgsA8MIVZrcRW62eyoU5ZnvWRxERGQZeAdWIiIikhTDCBEREUmKYYSIiIgkxTBCREREkmIYISIiIkkxjBBRpRw+fBhDhgyBp6cnZDIZdu7cWWb57du3o3///nBzc4OTkxOCgoKwf/9+nTJqtRoymUzvlZ+fX4VrQkRSYRghokrJzc1Fx44dsWrVqgqVP3z4MPr374+9e/fi1KlT6Nu3L4YMGYLU1FSdck5OTtBoNDovpVJZFatARBLjfUaIqFJCQ0MRGhpa4fKxsbE6w++99x527dqF3bt3w9/fXzteJpPBw8OjwvUWFBSgoKBAO5ydnV3heYlIWjwyQkSSKikpwd27d+Hqqnvn3ZycHHh7e6NJkyYYPHiw3pGTR8XExMDZ2Vn78vLyqspmE5EZMYwQkaQ+/PBD5ObmYsSIf56y3Lp1a6jVanz11VeIj4+HUqlE9+7dcfHiRaP1REVF4c6dO9pXZmZmdTSfiMyAp2mISDLx8fGIjo7Grl270KhRI+34wMBABAYGaoe7d++Ozp0746OPPsLKlSsN1qVQKKBQKKq8zURkfgwjRCSJhIQEhIeH44svvsBTTz1VZlkrKys8+eSTZR4ZISLLxdM0RFTt4uPjMX78eGzduhWDBg0qt7wQAmlpaVCpVNXQOiKqbjwyUkdpNBqcLeOeDfklJdq/z+fnQ2llPLfmXbGGjYuN2Z7cS5YlJycHly5d0g6np6cjLS0Nrq6uaNq0KaKionD16lVs3rwZwIMgMnbsWKxYsQKBgYHIysoCANjZ2cHZ2RkAsGDBAgQGBqJFixbIzs7GypUrkZaWho8//rj6V5CIqhzDSB0VFxeHBX9cqVDZlzIzyi4QDbgNdYP7c+6VbhdZnpMnT6Jv377a4cjISADAuHHjoFarodFokJHxz3soLi4ORUVFmDp1KqZOnaodX1oeAG7fvo1JkyYhKysLzs7O8Pf3x+HDh9G1a9cqW49zrdsYnXbv4XDu3xn2ZYRzRHG3SmQqfmrqqIiICLRXbzJLXXPCHhwZobqpT58+EEIYnV4aMEodOnSo3DqXL1+O5cuXV7JlRGQp+A1SR6lUKrQ1090s7Xz4NiKqC0rvhGsu92/f5+ldAsAwQkREFRQXF4cFCxaYrT6e3qVSDCNERFQhEREReOaZZ4xOz8vLQ48ePQAAR48ehZ2dXZn1jT4y2qztI8vFMEJERBWiUqnKvLw6NzdX+3enTp3g4OBQZn3yMzxFQw/wPiNEREQkKYYRIiIikhTDCBEREUmKYYSIiIgkxTBCREREkmIYISIiIkkxjBAREZGkGEaIiIhIUgwjREREJCmGESIiIpIUwwgRERFJimGEiIiIJMUwQkRERJJiGCEiIiJJMYwQERGRpGykbgARkdQ0Gg3O5ucbnZ5fUqL9+3x+PpRWxn/H5V2xho2LDeQucrO2kag2YxghojovLi4OC/64UqGyL2VmlF0gGnAb6gb359wr3S6iuoJhhIjqvIiICLRXbzJLXXPCHhwZqa3OtW5jdNq9h48g+XeGfRlHkAAAUbV3O5Fp+E4gojpPpVKhrVJplrrsfLhbJTLVY3VgXb16NXx9faFUKhEQEIAjR46UWb6goABz586Ft7c3FAoF/Pz8sGHDhsdqMBEREdUuJkf4hIQEzJgxA6tXr0b37t0RFxeH0NBQnD17Fk2bNjU4z4gRI/Dnn39i/fr1aN68Oa5fv46ioqJKN56IiIgsn8lhZNmyZQgPD8fEiRMBALGxsdi/fz/WrFmDmJgYvfL79u1DcnIyLl++DFdXVwCAj49P5VpNREREtYZJp2kKCwtx6tQphISE6IwPCQnBsWPHDM7z1VdfoUuXLliyZAkaN26Mli1b4rXXXkNeXp7R5RQUFCA7O1vnRURERLWTSUdGbty4geLiYri7616y5u7ujqysLIPzXL58GUePHoVSqcSOHTtw48YNTJkyBbdu3TLabyQmJgYLFiwwpWlERERkoR6rA6tMJtMZFkLojStVUlICmUyGzz77DF27dsXAgQOxbNkyqNVqo0dHoqKicOfOHe0rMzPzcZpJREREFsCkIyMNGzaEtbW13lGQ69ev6x0tKaVSqdC4cWM4Oztrx7Vp0wZCCPzvf/9DixYt9OZRKBRQKBSmNI2IiIgslElHRmxtbREQEICkpCSd8UlJSQgODjY4T/fu3XHt2jXk5ORox/33v/+FlZUVmjRp8hhNJiIiotrE5NM0kZGR+OSTT7BhwwacO3cOM2fOREZGBiZPngzgwSmWsWPHasuPHj0aDRo0QFhYGM6ePYvDhw/j9ddfx4QJE2BnZ2e+NSEiIiKLZPKlvSNHjsTNmzexcOFCaDQatGvXDnv37oW3tzeABw+cysj459kNjo6OSEpKwrRp09ClSxc0aNAAI0aMwKJFi8y3FkRERDWIRqOBRqMxS115V/Jq/cMXH+u+xVOmTMGUKVMMTlOr1XrjWrdurXdqh4iIqLaKi4sz61Whtf3hi3yIAhERkZlFRETgmWeeMTo9Ly8PPXr0AAAcPXq0zG4LI3aPqNUPXwQYRoiIiMxOpVJBpVIZnZ6bm6v9u1OnTnBwcDBa1u5M7e9f+Vj3GSEiIiIyF4YRIiIikhTDCBFVyuHDhzFkyBB4enpCJpNh586d5c6TnJyMgIAAKJVKNGvWDGvXrtUrk5iYiLZt20KhUKBt27bYsWNHFbSeiGoChhEiqpTc3Fx07NgRq1atqlD59PR0DBw4ED179kRqairefPNNTJ8+HYmJidoyKSkpGDlyJMaMGYOff/4ZY8aMwYgRI/Djjz9W1WoQkYTYgZWIKiU0NBShoaEVLr927Vo0bdoUsbGxAB48HuLkyZP44IMP8PzzzwMAYmNj0b9/f0RFRQF4cDPF5ORkxMbGIj4+3uzrQBWj0WhwNj/f6PT8khLt3+fz86G0Kvv37v3bilp97wyqOIYRIqpWKSkpCAkJ0Rk3YMAArF+/Hvfv34dcLkdKSgpmzpypV6Y0wBhSUFCAgoIC7XB2drZZ203//94Zf1ypUNmXMjPKLeN2sHbfO4MqjmGkGpjzTnxA+ZeMEdVkWVlZeg/WdHd3R1FREW7cuAGVSmW0zKMP6XxYTEyMWW8yRfoiIiLQXr3JbPXN7csHotIDDCPVwNx34ps/fz6io6PNVh9RdZPJZDrDQgi98YbKPDruYVFRUYiMjNQOZ2dnw8vLyxzNpf9PpVKhrVJptvrktfxGXlRxfCdUA3PeiQ8Aj4qQRfPw8NA7wnH9+nXY2NigQYMGZZZ59GjJwxQKBRQK/tImskQMI9XAnHfiI7J0QUFB2L17t864AwcOoEuXLpDL5doySUlJOv1GDhw4gODg4GptKxFVD4YRIqqUnJwcXLp0STucnp6OtLQ0uLq6omnTpoiKisLVq1exefNmAMDkyZOxatUqREZG4uWXX0ZKSgrWr1+vc5XMf/7zH/Tq1Qvvv/8+hg4dil27duHbb7/F0aNHq339iKjq8T4jRFQpJ0+ehL+/P/z9/QEAkZGR8Pf3x9tvvw3gQQfujIx/rqzw9fXF3r17cejQIXTq1AnvvPMOVq5cqb2sFwCCg4Oxbds2bNy4ER06dIBarUZCQgK6detWvStHRNWCR0aIqFL69Omj7YBqiFqt1hvXu3dvnD59usx6hw0bhmHDhlW2eURkAXhkhIiIiCTFMEJERESSYhghIiIiSTGMEBERkaTYgZWIiKgKnGvdxui0ew8/VNC/M+zLeqhgVO3/qq79a/iY+DwZIiKi6lGrwog5A0RcXBzWrVtnlroAPk+GiIjImFoVRsz9QLpJkyYhIiLC4DQ+T4aIiMg8alUYqYoH0hkLEXyeDBERkXnUqjDCB9IRERFZnloVRmoqnze+LnN6SWG+9u828/bBylZptOyVxYPM1i4iIqKagPcZISIiIkkxjBAREZGkGEaIiIhIUgwjREREJCmGESIiIpIUwwgRERFJimGEiIiIJMUwQkRERJJiGCEiIiJJMYwQERGRpBhGiIiISFJ8Nk0Z2m9qb3RaSUGJ9u+un3WFlaKsXLfYjK0iIiKqXWpdGDnXuo3RafdK/gkQ5/07w96qnANDUbVu8xARUTXQaDQ4m59vdHr+w99H+flQlvF9lHfFGjYuNpC7yM3axpqE37bVoCjnFopzbhmdLu4Xav8u/PMyZHJbo2VPnz4NlUoFlUpl1jYSEZH5xMXFYcEfVypU9qXMjLILRANuQ93g/px7pdtVUzGMVIOctG9w54f4CpX9c+vsMqcHbALmz5+P6OhoM7SMiIiqQkREBNqrN5mlrjlhD46M1Ga1e+1qCMdOobBr3s0sdX09vSePihAR1XAqlQptlUqz1GXnU/u/qmv/GtYANo6usHF0NUtdnTt3Nks9RERENQUv7SUiIiJJMYwQERGRpBhGiIiISFIMI0RERCQphhEiIiKSFMMIERERSYphhIiIiCTFMEJERESS4k3PjPirqAh5V+4bnV5y/5+HHOVl5MFKbjzXFWRdgrUZb3xGRERUmzCMGJFw+2/8Hn2zQmXT300vp8QMOHcfBZceL1a+YURERLVMrQoj5nxks7/SDt6zvGFTr/KbKDd9Gqx5VISIiMigWhVGzPrIZgBul8zzyOaivOaVroOoplu9ejWWLl0KjUaDJ554ArGxsejZs6fBsuPHj8emTfpPNG3bti1+++03AIBarUZYWJhemby8PCjN9AAyIqoZalUYMecjmwFgbl+F2eoiqs0SEhIwY8YMrF69Gt27d0dcXBxCQ0Nx9uxZNG3aVK/8ihUrsHjxYu1wUVEROnbsiOHDh+uUc3JywoULF3TGMYgQ1T61KoyY85HNACB3qVWbh6jKLFu2DOHh4Zg4cSIAIDY2Fvv378eaNWsQExOjV97Z2RnOzs7a4Z07d+Lvv//WOxIik8ng4eFRoTYUFBSgoKBAO5ydnf04q0JEEuClvURUKYWFhTh16hRCQkJ0xoeEhODYsWMVqmP9+vV46qmn4O3trTM+JycH3t7eaNKkCQYPHozU1FSjdcTExGhDjrOzM7y8vExfGSKSBMMIEVXKjRs3UFxcDHd33f5V7u7uyMrKKnd+jUaDb775RntUpVTr1q2hVqvx1VdfIT4+HkqlEt27d8fFixcN1hMVFYU7d+5oX5mZmY+/UkRUrXgegojMQiaT6QwLIfTGGaJWq+Hi4oJnn31WZ3xgYCACAwO1w927d0fnzp3x0UcfYeXKlXr1KBQKKBTs50VkiR7ryMjq1avh6+sLpVKJgIAAHDlypELz/fDDD7CxsUGnTp0eZ7FEVAM1bNgQ1tbWekdBrl+/rne05FFCCGzYsAFjxoyBra1tmWWtrKzw5JNPGj0yQkSWy+QwUtprfu7cuUhNTUXPnj0RGhqKjIyyL5W9c+cOxo4di379+j12Y4mo5rG1tUVAQACSkpJ0xiclJSE4OLjMeZOTk3Hp0iWEh4eXuxwhBNLS0qBSqSrVXiKqeUwOIw/3mm/Tpg1iY2Ph5eWFNWvWlDlfREQERo8ejaCgoMduLBHVTJGRkfjkk0+wYcMGnDt3DjNnzkRGRgYmT54M4EF/jrFjx+rNt379enTr1g3t2rXTm7ZgwQLs378fly9fRlpaGsLDw5GWlqatk4hqD5P6jJT2mn/jjTd0xpfXa37jxo34/fffsWXLFixatKjc5fASPSLLMnLkSNy8eRMLFy6ERqNBu3btsHfvXu3VMRqNRu/o6Z07d5CYmIgVK1YYrPP27duYNGkSsrKy4OzsDH9/fxw+fBhdu3at8vUhouplUhh5nF7zFy9exBtvvIEjR47AxqZii4uJicGCBQtMaRoRSWzKlCmYMmWKwWlqtVpvnLOzM+7du2e0vuXLl2P58uXmah4R1WCP1YG1or3mi4uLMXr0aCxYsAAtW7ascP28RI+IiKjuMOnIiKm95u/evYuTJ08iNTUVr776KgCgpKQEQgjY2NjgwIED+Ne//qU3Hy/RIyIiqjtMOjJiaq95JycnnDlzBmlpadrX5MmT0apVK6SlpaFbt26Vaz0RERFZPJNvehYZGYkxY8agS5cuCAoKwrp16/R6zV+9ehWbN2+GlZWVXi/5Ro0aQalUGuw9T0RERHWPyWHkcXrNExERERnzWLeDN7XX/MOio6MRHR39OIslIiKiWogPyiMiIiJJMYwQERGRpBhGiIiISFIMI0RERCQphhEiIiKSFMMIERERSYphhIiIiCTFMEJERESSYhghIiIiSTGMEBERkaQYRoiIiEhSDCNEREQkKYYRIiIikhTDCBEREUmKYYSIiIgkxTBCREREkmIYISIiIkkxjBAREZGkGEaIiIhIUgwjREREJCmGESIiIpIUwwgRERFJimGEiIiIJMUwQkRERJJiGCEiIiJJMYwQERGRpBhGiIiISFIMI0RERCQphhEiIiKSFMMIERERSYphhIiIiCTFMEJERESSYhghIrNYvXo1fH19oVQqERAQgCNHjhgte+jQIchkMr3X+fPndcolJiaibdu2UCgUaNu2LXbs2FHVq0FEEmAYIaJKS0hIwIwZMzB37lykpqaiZ8+eCA0NRUZGRpnzXbhwARqNRvtq0aKFdlpKSgpGjhyJMWPG4Oeff8aYMWMwYsQI/Pjjj1W9OkRUzRhGiKjSli1bhvDwcEycOBFt2rRBbGwsvLy8sGbNmjLna9SoETw8PLQva2tr7bTY2Fj0798fUVFRaN26NaKiotCvXz/ExsZW8doQUXVjGCGiSiksLMSpU6cQEhKiMz4kJATHjh0rc15/f3+oVCr069cPBw8e1JmWkpKiV+eAAQOM1llQUIDs7GydFxFZBoYRIqqUGzduoLi4GO7u7jrj3d3dkZWVZXAelUqFdevWITExEdu3b0erVq3Qr18/HD58WFsmKyvLpDpjYmLg7OysfXl5eVVyzYiouthI3QAiqh1kMpnOsBBCb1ypVq1aoVWrVtrhoKAgZGZm4oMPPkCvXr0eq86oqChERkZqh7OzsxlIiCwEj4wQUaU0bNgQ1tbWekcsrl+/rndkoyyBgYG4ePGidtjDw8OkOhUKBZycnHReRGQZGEaIqFJsbW0REBCApKQknfFJSUkIDg6ucD2pqalQqVTa4aCgIL06Dxw4YFKdRGQZeJqGiCotMjISY8aMQZcuXRAUFIR169YhIyMDkydPBvDgFMrVq1exefNmAA+ulPHx8cETTzyBwsJCbNmyBYmJiUhMTNTW+Z///Ae9evXC+++/j6FDh2LXrl349ttvcfToUUnWkYiqDsMIEVXayJEjcfPmTSxcuBAajQbt2rXD3r174e3tDQDQaDQ69xwpLCzEa6+9hqtXr8LOzg5PPPEEvv76awwcOFBbJjg4GNu2bcNbb72FefPmwc/PDwkJCejWrVu1rx8RVS2GESIyiylTpmDKlCkGp6nVap3h2bNnY/bs2eXWOWzYMAwbNswczSOiGox9RoiIiEhSDCNEREQkKYYRIiIikhTDCBEREUmKYYSIiIgkxTBCREREkmIYISIiIkkxjBAREZGkGEaIiIhIUgwjREREJCmGESIiIpIUwwgRERFJimGEiIiIJMUwQkRERJJiGCEiIiJJMYwQERGRpBhGiIiISFKPFUZWr14NX19fKJVKBAQE4MiRI0bLbt++Hf3794ebmxucnJwQFBSE/fv3P3aDiYiIqHYxOYwkJCRgxowZmDt3LlJTU9GzZ0+EhoYiIyPDYPnDhw+jf//+2Lt3L06dOoW+fftiyJAhSE1NrXTjiYiIyPLZmDrDsmXLEB4ejokTJwIAYmNjsX//fqxZswYxMTF65WNjY3WG33vvPezatQu7d++Gv7+/wWUUFBSgoKBAO5ydnW1qM4mIiMhCmHRkpLCwEKdOnUJISIjO+JCQEBw7dqxCdZSUlODu3btwdXU1WiYmJgbOzs7al5eXlynNJCIiIgtiUhi5ceMGiouL4e7urjPe3d0dWVlZFarjww8/RG5uLkaMGGG0TFRUFO7cuaN9ZWZmmtJMIiIisiAmn6YBAJlMpjMshNAbZ0h8fDyio6Oxa9cuNGrUyGg5hUIBhULxOE0jIiIiC2NSGGnYsCGsra31joJcv35d72jJoxISEhAeHo4vvvgCTz31lOktJSIiolrJpNM0tra2CAgIQFJSks74pKQkBAcHG50vPj4e48ePx9atWzFo0KDHaykRERHVSiafpomMjMSYMWPQpUsXBAUFYd26dcjIyMDkyZMBPOjvcfXqVWzevBnAgyAyduxYrFixAoGBgdqjKnZ2dnB2djbjqhAREZElMjmMjBw5Ejdv3sTChQuh0WjQrl077N27F97e3gAAjUajc8+RuLg4FBUVYerUqZg6dap2/Lhx46BWqyu/BkRERGTRHqsD65QpUzBlyhSD0x4NGIcOHXqcRRAREVEdwWfTEBERkaQYRoiIiEhSDCNEREQkKYYRIiIikhTDCBEREUmKYYSIiIgkxTBCREREkmIYISIiIkkxjBAREZGkGEaIiIhIUgwjRGQWq1evhq+vL5RKJQICAnDkyBGjZbdv347+/fvDzc0NTk5OCAoKwv79+3XKqNVqyGQyvVd+fn5VrwoRVTOGESKqtISEBMyYMQNz585FamoqevbsidDQUJ2HZj7s8OHD6N+/P/bu3YtTp06hb9++GDJkCFJTU3XKOTk5QaPR6LyUSmV1rBIRVaPHelAeEdHDli1bhvDwcEycOBEAEBsbi/3792PNmjWIiYnRKx8bG6sz/N5772HXrl3YvXs3/P39teNlMhk8PDyqtO1EJD0eGSGiSiksLMSpU6cQEhKiMz4kJATHjh2rUB0lJSW4e/cuXF1ddcbn5OTA29sbTZo0weDBg/WOnDysoKAA2dnZOi8isgwMI0RUKTdu3EBxcTHc3d11xru7uyMrK6tCdXz44YfIzc3FiBEjtONat24NtVqNr776CvHx8VAqlejevTsuXrxosI6YmBg4OztrX15eXo+/UkRUrRhGiMgsZDKZzrAQQm+cIfHx8YiOjkZCQgIaNWqkHR8YGIiXXnoJHTt2RM+ePfH555+jZcuW+OijjwzWExUVhTt37mhfmZmZlVshIqo27DNCRJXSsGFDWFtb6x0FuX79ut7RkkclJCQgPDwcX3zxBZ566qkyy1pZWeHJJ580emREoVBAoVCY1ngiqhF4ZISIKsXW1hYBAQFISkrSGZ+UlITg4GCj88XHx2P8+PHYunUrBg0aVO5yhBBIS0uDSqWqdJuJqGbhkREiqrTIyEiMGTMGXbp0QVBQENatW4eMjAxMnjwZwINTKFevXsXmzZsBPAgiY8eOxYoVKxAYGKg9qmJnZwdnZ2cAwIIFCxAYGIgWLVogOzsbK1euRFpaGj7++GNpVpKIqgzDCBFV2siRI3Hz5k0sXLgQGo0G7dq1w969e+Ht7Q0A0Gg0OvcciYuLQ1FREaZOnYqpU6dqx48bNw5qtRoAcPv2bUyaNAlZWVlwdnaGv78/Dh8+jK5du1bruhFR1WMYISKzmDJlCqZMmWJwWmnAKHXo0KFy61u+fDmWL19uhpYRUU3HPiNEREQkKYYRIiIikhTDCBEREUmKYYSIiIgkxTBCREREkmIYISIiIkkxjBAREZGkGEaIiIhIUgwjREREJCmGESIiIpIUwwgRERFJimGEiIiIJMUwQkRERJJiGCEiIiJJMYwQERGRpBhGiIiISFIMI0RERCQphhEiIiKSFMMIERERSYphhIiIiCTFMEJERESSYhghIiIiSTGMEBERkaQYRoiIiEhSDCNEREQkKYYRIiIikhTDCBEREUmKYYSIiIgkxTBCREREkmIYISIiIkkxjBAREZGkGEaIiIhIUgwjREREJCmGESIiIpIUwwgRERFJimGEiIiIJMUwQkRERJJiGCEiIiJJMYwQERGRpB4rjKxevRq+vr5QKpUICAjAkSNHyiyfnJyMgIAAKJVKNGvWDGvXrn2sxhJRzVUV+4XExES0bdsWCoUCbdu2xY4dO6qq+UQkIZPDSEJCAmbMmIG5c+ciNTUVPXv2RGhoKDIyMgyWT09Px8CBA9GzZ0+kpqbizTffxPTp05GYmFjpxhNRzVAV+4WUlBSMHDkSY8aMwc8//4wxY8ZgxIgR+PHHH6trtYiomtiYOsOyZcsQHh6OiRMnAgBiY2Oxf/9+rFmzBjExMXrl165di6ZNmyI2NhYA0KZNG5w8eRIffPABnn/+eYPLKCgoQEFBgXb4zp07AIDs7Oxy25dTXGzqKhlVnCczSz0lBffMUg9QsW1QUebaVubaTkDN3FZ8T/1TRghhcHpV7BdiY2PRv39/REVFAQCioqKQnJyM2NhYxMfH69VZmf0GwM9DRfHzUHF8T5W/79ASJigoKBDW1tZi+/btOuOnT58uevXqZXCenj17iunTp+uM2759u7CxsRGFhYUG55k/f74AwBdffNWwV2ZmZrXtF7y8vMSyZct0yixbtkw0bdqU+w2++LKwl6F9x8NMOjJy48YNFBcXw93dXWe8u7s7srKyDM6TlZVlsHxRURFu3LgBlUqlN09UVBQiIyO1wyUlJbh16xYaNGgAmcx8CbGysrOz4eXlhczMTDg5OUndnBqN26piaup2EkLg7t278PT01JtWVfsFY2WM1Wkp+w2g5v6faxpup4qrqduqrH3Hw0w+TQNA74MthCjzw26ovKHxpRQKBRQKhc44FxeXx2hp9XBycqpR//yajNuqYmridnJ2di5zelXsF0yp09L2G0DN/D/XRNxOFVcTt1V5+w7AxA6sDRs2hLW1td4vk+vXr+v9ginl4eFhsLyNjQ0aNGhgyuKJqAaqqv2CsTLG6iQiy2VSGLG1tUVAQACSkpJ0xiclJSE4ONjgPEFBQXrlDxw4gC5dukAul5vYXCKqaapqv2CsjLE6iciCldmjxIBt27YJuVwu1q9fL86ePStmzJghHBwcxJUrV4QQQrzxxhtizJgx2vKXL18W9vb2YubMmeLs2bNi/fr1Qi6Xiy+//NLURdc4+fn5Yv78+SI/P1/qptR43FYVY6nbqSr2Cz/88IOwtrYWixcvFufOnROLFy8WNjY24vjx49W+fuZmqf/n6sbtVHGWvq1MDiNCCPHxxx8Lb29vYWtrKzp37iySk5O108aNGyd69+6tU/7QoUPC399f2NraCh8fH7FmzZpKNZqIap6q2C988cUXolWrVkIul4vWrVuLxMTEql4NIpKATIjyLv4lIiIiqjp8Ng0RERFJimGEiIiIJMUwQkRERJJiGCEiIiJJMYyUIyYmBk8++STq1auHRo0a4dlnn8WFCxd0yowfPx4ymUznFRgYKFGLpRMdHa23HTw8PLTThRCIjo6Gp6cn7Ozs0KdPH/z2228StlgaPj4+ettJJpNh6tSpAPh+qi2476gY7jcqrjbvOxhGypGcnIypU6fi+PHjSEpKQlFREUJCQpCbm6tT7umnn4ZGo9G+9u7dK1GLpfXEE0/obIczZ85opy1ZsgTLli3DqlWrcOLECXh4eKB///64e/euhC2ufidOnNDZRqU39ho+fLi2DN9Plo/7jorjfqNiavO+47GeTVOX7Nu3T2d448aNaNSoEU6dOoVevXppxysUCp00X1fZ2NgY3A5CCMTGxmLu3Ln497//DQDYtGkT3N3dsXXrVkRERFR3UyXj5uamM7x48WL4+fmhd+/e2nF8P1k+7jsqjvuNiqnN+w4eGTHRnTt3AACurq464w8dOoRGjRqhZcuWePnll3H9+nUpmie5ixcvwtPTE76+vnjhhRdw+fJlAEB6ejqysrIQEhKiLatQKNC7d28cO3ZMquZKrrCwEFu2bMGECRN0HgDH91Ptw32HcdxvmK627Tt40zMTCCEwdOhQ/P333zhy5Ih2fEJCAhwdHeHt7Y309HTMmzcPRUVFOHXqlN5TRGuzb775Bvfu3UPLli3x559/YtGiRTh//jx+++03XLhwAd27d8fVq1d1HiU9adIk/PHHH9i/f7+ELZfO559/jtGjRyMjI0O7Xfh+qn247zCO+43HU+v2HVLd+tUSTZkyRXh7e4vMzMwyy127dk3I5fI6f+vqnJwc4e7uLj788EPxww8/CADi2rVrOmUmTpwoBgwYIFELpRcSEiIGDx5cZhm+nywf9x0Vx/1GxdS2fQdP01TQtGnT8NVXX+HgwYNo0qRJmWVVKhW8vb1x8eLFampdzeTg4ID27dvj4sWL2nOYfCT8P/744w98++23mDhxYpnl+H6ybNx3mIb7jfLVxn0Hw0g5hBB49dVXsX37dnz//ffw9fUtd56bN28iMzMTKpWqGlpYcxUUFODcuXNQqVTw9fWFh4eHziPhCwsLkZycXGcfCV/aoXHQoEFlluP7yTJx3/F4uN8oX63cd0h9aKame+WVV4Szs7M4dOiQ0Gg02te9e/eEEELcvXtXzJo1Sxw7dkykp6eLgwcPiqCgING4cWORnZ0tceur16xZs8ShQ4fE5cuXxfHjx8XgwYNFvXr1tI+RX7x4sXB2dhbbt28XZ86cEaNGjRIqlarObSchhCguLhZNmzYVc+bM0RnP91PtwX1HxXC/YZrauu9gGCkHAIOvjRs3CiGEuHfvnggJCRFubm5CLpeLpk2binHjxomMjAxpGy6BkSNHCpVKJeRyufD09BT//ve/xW+//aadXlJSIubPny88PDyEQqEQvXr1EmfOnJGwxdLZv3+/ACAuXLigM57vp9qD+46K4X7DNLV138GraYiIiEhS7DNCREREkmIYISIiIkkxjBAREZGkGEaIiIhIUgwjREREJCmGESIiIpIUwwgRERFJimGEiIiIJMUwQkRERJJiGCEiIiJJMYwQERGRpP4fQxuC0lHup7YAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x800 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "real_time_order_dispatch_algorithm()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0fd8daaa",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}