Cognitive Map Learner.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3f039924",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import necessary libraries\n",
    "import torch\n",
    "from torch.utils.data import Dataset, DataLoader  \n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import numpy as np\n",
    "from tqdm.notebook import tqdm\n",
    "from sklearn.manifold import TSNE\n",
    "from sklearn.decomposition import PCA\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.ticker import MaxNLocator\n",
    "import networkx as nx\n",
    "import numpy as np\n",
    "import random\n",
    "\n",
    "# Set the device to GPU if available\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0c31d4ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "# function to generate a random graph\n",
    "def construct_random_subgraph(num_nodes, min_edges=2, max_edges=5):\n",
    "    min_edges-=1\n",
    "    max_edges-=1\n",
    "    connections = np.random.uniform(size=(num_nodes, num_nodes))\n",
    "    connections += np.roll(np.eye(num_nodes), 1, 1)  # make sure every node is connected\n",
    "    connections -= np.eye(num_nodes)  # make sure no self-connections\n",
    "    # set strongest connections\n",
    "    sorted_connections = np.sort(connections)[:, ::-1]\n",
    "    min_edges = min_edges\n",
    "    max_edges = max_edges + 1\n",
    "    min_edges = int(min_edges / 2 + 0.5)  # used to be min_edges // 2\n",
    "    max_edges = int(max_edges / 2 + 0.5)\n",
    "    indices = np.stack([np.arange(num_nodes), np.random.randint(min_edges, max_edges, num_nodes)])\n",
    "    thresholds = sorted_connections[indices[0], indices[1]]\n",
    "    connections = np.where(connections > thresholds[:, None], 1., 0.).astype(np.float32)\n",
    "    connections = np.clip(connections + connections.T, 0, 1)\n",
    "    return connections\n",
    "\n",
    "# function to generate a random small world graph\n",
    "def construct_small_world_graph(n_nodes_per_world=6, n_worlds=4):\n",
    "    n_nodes = n_nodes_per_world * n_worlds\n",
    "    connections = np.zeros((n_nodes, n_nodes))\n",
    "    for world_i in range(n_worlds):\n",
    "        connection = construct_random_subgraph(n_nodes_per_world)\n",
    "        # add to global graph\n",
    "        start_i = world_i * n_nodes_per_world\n",
    "        end_i = (world_i+1) * n_nodes_per_world\n",
    "        connections[start_i:end_i, start_i:end_i] = connection\n",
    "        # connect to graph\n",
    "        if world_i != 0:\n",
    "            node_from = np.random.randint(start_i, end_i)\n",
    "            node_to = node_from - n_nodes_per_world\n",
    "            connections[node_from, node_to] = 1\n",
    "            connections[node_to, node_from] = 1\n",
    "    return connections\n",
    "\n",
    "# function to generate a dead ends graph\n",
    "def construct_dead_ends_graph():\n",
    "    # construct the shell-like connectivity\n",
    "    n_shells = 4\n",
    "    n_neurons_per_shell = 6\n",
    "    layers_with_circular_connection = [1]\n",
    "    size = n_shells * n_neurons_per_shell\n",
    "    connections = np.zeros((size, size)).astype(np.float32)\n",
    "    eye = np.eye(n_neurons_per_shell)\n",
    "    for i in range(n_shells):\n",
    "        if i in layers_with_circular_connection:\n",
    "            # add circular connection\n",
    "            idx = i * n_neurons_per_shell\n",
    "            connections[idx:idx+n_neurons_per_shell, idx:idx+n_neurons_per_shell] = np.roll(eye, 1, axis=1)\n",
    "\n",
    "        # add connections to next shell\n",
    "        if i + 1 < n_shells:\n",
    "            # connect to outer shell\n",
    "            idx = i * n_neurons_per_shell\n",
    "            j = idx + n_neurons_per_shell\n",
    "            connections[idx:idx+n_neurons_per_shell, j:j+n_neurons_per_shell] = eye\n",
    "\n",
    "    connections = connections + connections.T\n",
    "    return connections\n",
    "\n",
    "# function to generate a grid graph with numerical paths to move to a target\n",
    "def construct_grid_graph():\n",
    "    n = 4\n",
    "    l = 5\n",
    "    n_nodes = n * l + l // 2\n",
    "\n",
    "    tmp_n_nodes = 0\n",
    "    layer_index_bounds = []\n",
    "    for i in range(l):\n",
    "        tmp_n_nodes += n if i % 2 == 0 else n + 1\n",
    "        layer_index_bounds.append(tmp_n_nodes)\n",
    "\n",
    "    connections = []\n",
    "\n",
    "    lower_idx = 0\n",
    "    for layer_idx in range(l):\n",
    "        upper_idx = layer_index_bounds[layer_idx]\n",
    "        for i in range(lower_idx, upper_idx):\n",
    "            if i + 1 < upper_idx:\n",
    "                connections.append([i, i + 1])\n",
    "            if layer_idx + 1 < l:\n",
    "                # not last layer\n",
    "                next_upper_idx = layer_index_bounds[layer_idx+1]\n",
    "                dist1 = n if layer_idx % 2 == 0 else n + 1\n",
    "                dist2 = n + 1 if layer_idx % 2 == 0 else n\n",
    "                if upper_idx <= i + dist1 < next_upper_idx:\n",
    "                    connections.append([i, i + dist1])\n",
    "                if upper_idx <= i + dist2 < next_upper_idx:\n",
    "                    connections.append([i, i + dist2])\n",
    "        lower_idx = upper_idx\n",
    "    connections = np.array(connections)\n",
    "    i, j = connections.T\n",
    "    adj = np.zeros((n_nodes, n_nodes))\n",
    "    adj[i, j] = 1\n",
    "    adj += adj.T\n",
    "    return adj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a259fe6b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a dataset of trajectories\n",
    "class RandomWalkDataset(Dataset):\n",
    "    def __init__(self, adj_matrix, trajectory_length, num_trajectories):\n",
    "        self.adj_matrix = adj_matrix\n",
    "        self.num_trajectories = num_trajectories\n",
    "        self.trajectory_length = trajectory_length\n",
    "        self.edges, self.action_indices = edges_from_adjacency(adj_matrix)\n",
    "        start_nodes = torch.randint(0, adj_matrix.size(0), (num_trajectories,)).tolist()\n",
    "        self.data = []\n",
    "        for node in start_nodes:\n",
    "            trajectory = strict_random_walk(self.adj_matrix, node, self.trajectory_length, self.action_indices)\n",
    "            self.data.append(torch.tensor([(x[0], x[1], x[2]) for x in trajectory]))\n",
    "    def __len__(self):\n",
    "        return self.num_trajectories  # Number of trajectories\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        return self.data[idx]\n",
    "    \n",
    "    \n",
    "# function to generate random walk trajectories on a given graph\n",
    "def strict_random_walk(adj_matrix, start_node, length, action_indices):\n",
    "    current_node = start_node\n",
    "    trajectory = []\n",
    "    for _ in range(length - 1):  # subtract 1 to account for the start node\n",
    "        neighbors = torch.where(adj_matrix[current_node] > 0)[0].tolist()\n",
    "        if not neighbors:\n",
    "            break\n",
    "        next_node = neighbors[torch.randint(0, len(neighbors), (1,)).item()]\n",
    "        trajectory.append((current_node, action_indices[(current_node, next_node)], next_node))\n",
    "        current_node = next_node\n",
    "    return trajectory\n",
    "\n",
    "# indexing each action for a given adjacency matrix\n",
    "def edges_from_adjacency(adj_matrix):\n",
    "    # The input is a given random matrix's adjacency matrix\n",
    "    # The outputs are:\n",
    "        # edges: a list of pairs of (start node, end node) for each action\n",
    "        # action_indices: a dictionary, each key is a pair of(start node, end node),\n",
    "            # and its corresponding value is this action's index\n",
    "    # For a pure on-line algorithm, this can also be done by assigning index to unseen actions\n",
    "    # during random-walk on-line\n",
    "    n = adj_matrix.shape[0]\n",
    "    edges = []\n",
    "    action_idx = 0\n",
    "    action_indices = {}\n",
    "    for i in range(n):\n",
    "        for j in range(i+1, n):  # Only upper triangle\n",
    "            if adj_matrix[i][j] != 0:\n",
    "                edges.append((i, j))\n",
    "                action_indices[(i, j)] = action_idx\n",
    "                action_idx += 1\n",
    "                edges.append((j, i))\n",
    "                action_indices[(j, i)] = action_idx\n",
    "                action_idx += 1\n",
    "    return edges, action_indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "30071b2b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class GraphEnv():\n",
    "    def __init__(self, size=32, env='random'):\n",
    "        if env == 'random':\n",
    "            self.adj_matrix = construct_random_subgraph(size, 2, 5)\n",
    "        elif env == 'small world':\n",
    "            self.adj_matrix = construct_small_world_graph()\n",
    "        elif env == 'dead ends':\n",
    "            self.adj_matrix = construct_dead_ends_graph()\n",
    "        elif env == 'grid':\n",
    "            self.adj_matrix = construct_grid_graph()\n",
    "        self.adj_matrix = torch.tensor(self.adj_matrix)\n",
    "        self.size = self.adj_matrix.shape[0]\n",
    "        self.affordance, self.node_to_action_matrix,\\\n",
    "        self.action_to_node = node_outgoing_actions(self.adj_matrix)\n",
    "        \n",
    "        self.affordance = {k: torch.tensor(v).to(device)\\\n",
    "                           for k, v in self.affordance.items()}\n",
    "        self.node_to_action_matrix = self.node_to_action_matrix.to(device)\n",
    "        self.action_to_node = {k: torch.tensor(v).to(device) \\\n",
    "                            for k, v in self.action_to_node.items()}\n",
    "        \n",
    "        self.dataset = RandomWalkDataset(self.adj_matrix, batch_size,\\\n",
    "                                         num_desired_trajectories)\n",
    "        self.n_actions = len(self.dataset.action_indices)\n",
    "        \n",
    "def node_outgoing_actions(adj_matrix):\n",
    "    # This function creates several look-up tables for later computation's convecience\n",
    "    edges, action_indices = edges_from_adjacency(adj_matrix)\n",
    "    # Use an action index as a key, retrieve its (start node, end node)\n",
    "    inverse_action_indices = {v: k for k, v in action_indices.items()}\n",
    "    # Given a node as a key, retrieve all of its available outgoing actions' indexes.\n",
    "    node_actions = {}\n",
    "    # Given a pair of (start node, end node), get the action index.\n",
    "    # Since a index can be 0, this matrix is initialized to be a all -1.\n",
    "    node_to_action_matrix = -1*torch.ones_like(adj_matrix)\n",
    "    for edge in edges:\n",
    "        node_from, node_to = edge\n",
    "        if node_from not in node_actions:\n",
    "            node_actions[node_from] = []\n",
    "        node_actions[node_from].append(action_indices[edge])\n",
    "        node_to_action_matrix[node_from][node_to] = action_indices[edge]  \n",
    "    return node_actions, node_to_action_matrix.long(), inverse_action_indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b0abbb5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Agent(nn.Module):\n",
    "    def __init__(self, o_size, a_size, s_dim):\n",
    "        super(Agent, self).__init__()\n",
    "        self.Q = nn.Parameter(1*torch.randn(s_dim, o_size, device=device))\n",
    "        self.V = nn.Parameter(0.1*torch.randn(s_dim, a_size, device=device))\n",
    "        self.W = nn.Parameter(0.1*torch.randn(a_size, s_dim, device=device))\n",
    "        self.o_size = o_size\n",
    "        self.a_size = a_size\n",
    "    def forward(self, o_pre, action, o_next):\n",
    "        prediction_error = self.Q[:,o_next]-(self.Q[:,o_pre]+self.V[:,action])\n",
    "        return prediction_error\n",
    "    def plan(self, start, goal, env, weight=False):\n",
    "        a_record = []\n",
    "        o_record = []\n",
    "        loc = int(start)\n",
    "        length = 0\n",
    "        for i in range(self.o_size):\n",
    "            o_record.append(loc)\n",
    "            if loc==goal:\n",
    "                if weight:\n",
    "                    return length, o_record\n",
    "                else:\n",
    "                    return i, o_record\n",
    "            loc, action = self.move_one_step(loc, goal, a_record, env.affordance[loc], \n",
    "                    env.action_to_node, env.node_to_action_matrix[loc], weight)\n",
    "            a_record.append(action)\n",
    "            if weight:\n",
    "                length += w_connection[o_record[-1],loc]\n",
    "\n",
    "        if weight:\n",
    "            return length, o_record\n",
    "        else:\n",
    "            return i, o_record\n",
    "    def move_one_step(self, loc, goal, a_record, affordance, action_to_node,\n",
    "                      next_node_to_action,weight=False):  \n",
    "        affordance_vector = torch.zeros(self.a_size, device=device)\n",
    "        affordance_vector[affordance] = 1\n",
    "        if weight:    \n",
    "            for a in affordance:\n",
    "                a = a.item()\n",
    "                affordance_vector[a]/=(w_connection[action_to_node[a][0],\n",
    "                                                    action_to_node[a][1]])\n",
    "        affordance_vector_fix = affordance_vector.clone()\n",
    "        not_recommended_actions = a_record\n",
    "        affordance_vector_fix[not_recommended_actions] *= 0.\n",
    "\n",
    "        delta = self.Q[:,goal]-self.Q[:,loc]\n",
    "        utility = (self.W@delta) * affordance_vector_fix\n",
    "        if torch.max(utility)!=0:\n",
    "            action_idx = torch.argmax(utility).item()\n",
    "        else:\n",
    "            utility = (self.V.T@delta) * affordance_vector\n",
    "            action_idx = torch.argmax(utility).item()\n",
    "\n",
    "            \n",
    "        return action_to_node[action_idx][1].item(), action_idx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6a8a6567",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_model(model, dataloader, epochs, norm=False):\n",
    "    with torch.no_grad():\n",
    "        loss_record = []\n",
    "        for epoch in tqdm(range(epochs), desc=\"Epochs\"):\n",
    "            count = 0\n",
    "            for trajectory in dataloader:\n",
    "                count += 1\n",
    "                o_pre, action, o_next = trajectory[0,:,0].to(device),\\\n",
    "                                        trajectory[0,:,1].to(device),\\\n",
    "                                        trajectory[0,:,2].to(device)\n",
    "                identity = torch.eye(model.a_size).to(device)\n",
    "                state_diff = model.Q[:,o_next]-model.Q[:,o_pre]\n",
    "                prediction_error = state_diff - model.V[:,action]\n",
    "                desired = identity[action].T\n",
    "                \n",
    "                # Core learning rules:\n",
    "                model.Q[:,o_next] += -0.1 * prediction_error\n",
    "                model.V[:,action] += 0.01 * prediction_error\n",
    "                model.W += 0.01 * desired@state_diff.T\n",
    "                if norm:\n",
    "                    model.V.data = model.V / torch.norm(model.V, dim=0)\n",
    "\n",
    "                loss = nn.MSELoss()(prediction_error, torch.zeros_like(prediction_error))\n",
    "                loss_record.append(loss.cpu().item())\n",
    "    return loss_record"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "0db7c94e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_model(model, env, print_results=True):\n",
    "    N_nodes = model.o_size\n",
    "    dis = []\n",
    "    D_dis = []\n",
    "    N_goal = 1000\n",
    "    adj_matrix_tensor = env.adj_matrix.to(device)\n",
    "    graph = nx.from_numpy_matrix(env.adj_matrix.cpu().numpy(), create_using=nx.DiGraph())\n",
    "    for i in range(N_goal):\n",
    "        start_idx = torch.randint(N_nodes, (1,)).to(device)[0]\n",
    "        goal_idx = torch.randint(N_nodes, (1,)).to(device)[0]\n",
    "        with torch.no_grad():\n",
    "            steps, o_record = model.plan(start_idx, goal_idx, env, False)\n",
    "        D_path = nx.shortest_path(graph, source=int(start_idx.cpu()), target=int(goal_idx.cpu()))\n",
    "        D_steps = len(D_path) - 1\n",
    "        dis.append(steps)\n",
    "        D_dis.append(D_steps)\n",
    "\n",
    "    # Convert lists to tensors and move them to GPU\n",
    "    dis = torch.tensor(dis).float().to(device)\n",
    "    D_dis = torch.tensor(D_dis).float().to(device)\n",
    "    mask = dis != (N_nodes-1)\n",
    "    mean_CML = torch.mean(dis).item()\n",
    "    std_CML = torch.std(dis).item()\n",
    "    mean_Dij = torch.mean(D_dis).item()\n",
    "    std_Dij = torch.std(D_dis).item()\n",
    "    if print_results:\n",
    "        print('CML steps:', str(mean_CML)[:6], ', Success Rate:', str((mask.sum() / N_goal * 100).item())[:6] + '%',\n",
    "          ', Dij steps:', str(mean_Dij)[:6], ', Percentage worse:', str((mean_CML / mean_Dij - 1) * 100)[:6] + '%')\n",
    "        print('CML std: ', str(std_CML)[:6], ' Dij std: ', str(std_Dij)[:6])\n",
    "    else:\n",
    "        return mean_CML\n",
    "# "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "1e0bc9cc",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "cf7a782476a24f649f6986957c92daea",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_nodes = 32\n",
    "batch_size = 32\n",
    "state_dim = 1000\n",
    "epochs = 10\n",
    "\n",
    "num_desired_trajectories=200\n",
    "# choose env from \"random\", \"small world\" or \"dead ends\"\n",
    "env = GraphEnv(n_nodes, env='random')\n",
    "\n",
    "dataset = RandomWalkDataset(env.adj_matrix, batch_size, num_desired_trajectories)\n",
    "dataloader = DataLoader(dataset, batch_size=1, shuffle=True)\n",
    "model = Agent(env.size, env.n_actions, state_dim)\n",
    "\n",
    "\n",
    "loss_record= train_model(model, dataloader, epochs, norm=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "544e77ef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'Number of weight updates')"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams['font.size'] = 15\n",
    "plt.figure(dpi=100)\n",
    "plt.plot(loss_record)\n",
    "plt.yscale('log')\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Number of weight updates')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "75a495f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CML steps: 3.5690 , Success Rate: 100.0% , Dij steps: 3.3360 , Percentage worse: 6.9844%\n",
      "CML std:  1.7216  Dij std:  1.4653\n"
     ]
    }
   ],
   "source": [
    "test_model(model, env)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "475d9279",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/yukun/anaconda3/lib/python3.9/site-packages/sklearn/manifold/_t_sne.py:982: FutureWarning: The PCA initialization in TSNE will change to have the standard deviation of PC1 equal to 1e-4 in 1.2. This will ensure better convergence.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY0AAAGLCAYAAAA7/s7MAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAAexAAAHsQEGxWGGAADSm0lEQVR4nOydd1gT2fv271BFBBsKgh1pYgULoqiIomIXUde1997r2rBhRUV0Layd7yqKvYKIBQQbdqQo6oog2FBAkJbn/YM355chAZIQijqf65rLZMqZM4OZe85zniIgIgIPDw8PD48MqJR2B3h4eHh4fh540eDh4eHhkRleNHh4eHh4ZIYXDR4eHh4emVGTtrJ///6oW7duCXeFh4eHh6es8ebNG5w8eZJ9lyoadevWxebNm0usUzw8PDw8ZZPZs2dzvvPmKR4eHh4emeFFg4eHh4dHZnjR4OHh4eGRGV40eHh4eHhkhhcNHh4eHh6Z4UWDh4eHh0dmeNHg4eHh4ZEZXjR4eHh4eGSGFw0eHh4eHpnhRYOHh4eHR2Z40eDh4eHhkRleNHh4eHh4ZIYXDR4eHh4emeFFg4eHh4dHZnjR4OHh4eGRGV40eHh4eHhkhhcNHh4eHh6Z4UWDh4eHh0dmeNHg4eHh4ZEZXjR4eHh4eGSGFw0eHh4eHpnhRYOHh4eHR2Z40eDh4eHhkRm10u4AD09ehEIhoqOjERYWhoSEBGRmZkJDQwMGBgawtraGqakpVFT49x0entKAFw2eMkV4eDj8/f2RnJwMIyMjWFlZQVNTExkZGYiJiYGPjw90dXXh6OgIS0vL0u4uD89vBy8aPGWG27dvw8/PDxYWFhg0aBAMDQ052+3t7REfH4/g4GD4+voiJSUFNjY2xd4vfuTDw/N/8KLBUyYIDw+Hn58fbG1t0blzZwgEAqn7GRoawsXFBQEBAfDz84OOjk6xjjj4kQ8PDxdeNHhKHaFQCH9/f1hYWBQoGCIEAgE6d+6ML1++sOOK402/rI58eHhKE35MzVPqREdHIzk5GXZ2doUKhgiBQAA7OzskJyfjxYsXSu+T+MjHxcVFQjBEiEY+tra28PPzQ3h4uNL7wsNTluBFg6fUCQsLg5GREWrUqCHXcYaGhjAyMsL9+/eV2h9FRz7m5ubw9/eHUChUan94eMoSvGjwlDoJCQkwNjZW6FhjY2MkJiYqtT9lceTDw1NW4EWDp9TJzMyEpqamQseKJqWVSVkb+fDwlCV40eApdTQ0NBR+8GdkZCgsOPlR1kY+PDxlCV40eEodAwMDxMTEKHRsTEwM9PX1ldqfsjby4eEpS/CiwVPqWFtbIy4uDvHx8XIdFx8fj7i4OLRo0UKp/SlrIx8enrIELxo8pY6pqSl0dXURHBwMIpLpGCLCzZs3UbFiRZiYmCi1P+XLl0d0dLRCxxbHyIeHpyzBiwZPqaOiogJHR0dEREQgICCgUOEgIgQEBCAqKgpJSUkyezgVxocPHzBu3Dhs27YNCQkJZWbkw8NTluAjwnnKBJaWlkhJSYGfnx+SkpLQrl07qQF18fHxuHnzJqKionD58mXcvn0bsbGx2L17N9TV1RU6d2ZmJrZv344VK1YgOTkZKioq+P79O4KCgjBw4ECZRImIEBQUVCwjHx6esgQvGjxlBhsbG+jo6MDf3x9eXl7Q19eHmZkZJ9dTXFwcdHV1oaWlhTt37gAA9u/fj7i4OPj6+kJHR0euc166dAmzZs1CVFQUW1ehQgVUqVIFkZGRCAgIKDTATzTyiYyMxIABA/jkhTy/NLxo8JQpLC0tYWFhgRcvXmDjxo148+YNNDQ0UKlSJejr62Pw4MEwMTGBiooK6tevj6FDhyIjIwP+/v5o3749Ll68KFN8RXR0NGbPno0LFy6wdQKBAGPGjMHq1auhr6/Pck/JOvJp2bIln7SQ55eHFw2eMoeKigrMzMzg6+uLb9++wczMDJGRkRL7DRgwAAYGBujduzeSkpLw6NEj2NjY4PLly7CwsJDa9rdv37Bq1Sps27YNWVlZbH3btm3h4eEBa2trtk408vHz85M68omOjkZCQgK+f/+Oixcv4unTp3ByclL+DeHhKUPwosFTZhE91Auaq2jXrh1CQkLQrVs3/Pfff3j79i1sbW1x5swZtG/fnu0nFApx4MABLFq0CB8+fGDrjYyMsHHjRgwePFiqCcrS0hKRkZFYvHgxWrVqhcTERGRnZyMrKws/fvzA8OHD0aNHDyQkJCA8PBxXrlxBly5dlHgXeHjKGCSFWbNmSVvNw1OiqKurEwBq3rx5ofu+f/+erKysCAABIA0NDfLx8SEiolu3bpG1tTXbBoDKlStHS5cupdTU1ELbnjBhAjvu4sWLpK2tTQDIzMyMiIgOHDjAtpubm1NGRkbRLpyHpwyRVw/4GTueMgkRyTTSEGFgYIDr16+jW7duAHI9ogYNGgQrKyu0bdsWYWFhbN8BAwYgIiICK1euhLa2dqFtX7lyBUBu0F/79u3ZnMn79+8BAMOGDWN1NCIjI+Hp6SnHlfLw/FzwosFTJsnJyWGfZXWl1dHRwdmzZzFixAi27uHDh+xz48aNERgYiOPHj6Nu3boytRkTE4NXr14ByJ330NbWZqKRnJyMtLQ0qKioYPv27cy85erqygSFh+dXgxcNnjJJZmYm+yyraBARzp49ixs3bkhsa9asGW7dugV7e3u5+uHv788+Ozo6AgDHi0okDtbW1hg/fjwAIDU1FQsWLJDrPDw8Pwu8aPCUScQ9m2QRjSdPnsDBwQEDBgzAmzdvAOR6YYne/h89eoRu3brh8+fPcvVDZJoCwCa4xV16xUcUa9asQeXKlQEAhw8fRnBwsFzn4uH5GeC9p3iUhlAoRHR0NMLCwpCQkIDMzExoaGjAwMAA1tbWMDU1lTnwTVbR+Pz5M5YtW4Zdu3ZxKuZ17twZW7duxbt37zBgwACkpqYiJCQEtra2uHz5MurVq1doH7Kzs3H16lUAQNWqVdG8eXMAXNEQTzVStWpVrFmzBpMnTwYATJs2Dffv34eqqqpM18zD8zPAjzR4lEJ4eDg8PDzg4+OD9PR0WFlZoUOHDrCyskJ6ejp8fHzg4eEhcw1tcdHQ0NCQ2J6dnY3t27fDxMQEf//9NxOM+vXr4/Tp0/D394elpSW6du2KGzduwMDAAEBuUJ+NjY1MhZLu3r2L5ORkALmjDJHg5TfSAIDx48ejWbNmAHJHN3v27JHpenl4fhb4kQZPkRFFTltYWGDQoEESkdP29vaIj49HcHAwfH19kZKSwryN8qOgkUZAQABmzpzJESBtbW0sWbIEM2fORLly5Tj7W1lZITQ0FN27d0dkZCQ+fPiAjh074tixYwUG40kzTQEFi4aqqiq2b9+Odu3aAQAWL14MFxcX6OnpFXi9PDw/C/xIg6dIhIeHw8/PD7a2tnBxcZGaagPInTx2cXGBra0t/Pz8Ch1xSBONV69eoV+/fujSpQvn+OHDhyM6OhoLFy6UEAwRdevWxa1bt2BnZwcA+P79O3r37g0vL698+yA+CS6raAC5XlbDhg0DACQlJWHJkiUFXisPz88ELxo8CiMUCuHv7w8LC4tCk/oBubmdOnfuDHNzc/j7+3PmIPIiLhoA8Ndff8HCwgKnT59m61q1aoXQ0FAcPHgwX7ESp0qVKvD394eLiwuAXLfe8ePHY9myZRLp2L99+8YSIpqbm6NWrVpsmzTvqbysX7+eJU/cs2cPJ06Eh+dnhhcNHoWJjo5GcnIy7OzsZK5pIRAIYGdnh+TkZLx48SLf/cRF4/Tp01i7di1zwzUwMMCBAwcQGhpaqJkrL+XKlcPRo0cxe/Zstm7VqlUYNWoU55zXrl1jsSIiV1sRlSpVYtX58hONGjVqYPny5QByXYGnTp1aoEjy8Pws8KLBozBhYWEwMjKSKausOIaGhjAyMipwMlo8KC8tLQ1A7oT4ggULEB0djREjRiicglxFRQXu7u7YsmULE7uDBw+iR48ebOJbWnyGCIFAwK65oEJN06ZNg7m5OYDceZ/Dhw8r1F8enrIELxo8CpOQkABjY2OFjjU2NkZiYqLE+vfv32PUqFGcqG4A6N27N8LDw7Fu3Tq5a2bkx8yZM3Hs2DE2arhy5Qo6dOiA+Ph4Jhrq6uro0KGDxLEi0fjy5Uu+9cQ1NDSwbds29n3+/Pn49u2bUvrOw1Na8KLBozCZmZnsgSsvovTiIjIyMrBhwwaYmpriwIEDnH2dnZ1x5swZNGjQoCjdlcqAAQMQEBCAKlWqAMh1k23ZsiViYmIAALa2tqhQoYLEceKjq4SEhHzb79KlC5ydnQHklpNdsWKFMrvPw1Pi8KLBozAaGhr5vmUXRkZGBjQ1NUFEOHfuHBo1aoQFCxYgNTUVADgP6uIun9quXTvcunWL5aMSNznlNU2JKMyDShx3d3doaWkBALZt2yZzrAoPT1mEFw0ehTEwMGBv5PISExMDbW1tdOvWDb1798bLly8B5M43TJw4EXv37mX7Klr7Wx7Mzc0RGhoKKysrmfaXxYNKRJ06dbBo0SIAuR5b06ZNk/DW4uH5WeBFg0dhrK2tERcXV+BksDTi4+MRFxcHDw8PzoRzhw4dEBYWhp07d3JSlpeEaAC5Inj16lWoqf1fzOvixYvh7u4u8ZCXZ6QBAPPmzWOpS65duwZfX18l9ZqHp2ThRYNHYUxNTaGrq4vg4GCZ35yJCDdv3kRqaior4Vq7dm0cO3YM165dYyk4FMlyqwwiIyORnZ3NWTd37lzMnDmTk649v/xT+VGuXDls3bqVfZ89eza+f/9e9A7z8JQwvGjwKIyKigocHR0RERGBgICAQoWDiBAQEICoqChcunQJ5cqVw4oVKxAZGQkXFxdOrIe8WW6VhfjIp3fv3uzztm3b4OLigvT0dADyjzQAoFevXujevTsA4N27d1i7dq0yuszDU6LwosFTJERJAUNCQnD8+PF837rj4+Ph4+ODkJAQXL58GU2aNEFUVBSWLVvGJonFKS3REM83tW3bNuzfv5+Zq06dOgUHBwd8+vRJIdEQCATYunUru56NGzeyuRwenp8FPmEhT5GxsbGBjo4O/P394eXlBX19fZiZmTG32qioKCQmJuL79+8IDQ3Fxo0bWUK//Cgsy21xkJycjNDQUACAmZkZ6tSpg5EjR6JGjRosvXpoaCjatm2LCxcuQE1NDdnZ2XJV6TM1NcWcOXOwbt06ZGZmYubMmTh//nxxXRIPj9LhRYNHKVhaWsLCwgJ37tzBzp078ebNG6irqyMrKwvx8fG4e/cuoqOjUb58eZlqWZTGSEM8dYh4gsKuXbvi5s2bcHJyQkJCAqKjo9G2bVtUrlwZHz9+lLu06+LFi3H48GHExcXhwoULOH/+PHr27KnUa+HhKS548xSP0nj8+DFmzJiBw4cPY/369Vi9ejXc3d1RrVo1tGnTBkSE79+/Y/78+YW2VRqiIW6ayhuf0bx5c9y+fRsWFhYAcgP1RFUAP3z4IDF5XhAVKlTApk2b2PeZM2fix48fRek6D0+JwYsGT5H5+PEjxo8fD2tra9y7d4+tNzIywtOnT+Hu7o5NmzaxqOt///0XN2/eLLDN0hAN0SS4mpoaOnbsKLG9Tp06CA4OZunVRQkIiQgfPnyQ61yDBg1i6UliYmKwefPmIvSch6fk4EWDR2GysrKwZcsWmJiYwMvLS8J7qk+fPixhX9WqVeHm5sa2TZ06tcC385IWjTdv3rCsu23atMk3v5UovfrAgQM565cuXSpXwJ5AIICnpycrBbt69Wq8fftWwd7z8JQcvGjwKITIA2r27NksCZ+Ojg6rjw1Awitq7NixLOL66dOn2LlzZ77tl7RoFGSayku5cuVw5MgRtGnThq3bt28fRo4cyYkvKYzGjRtjypQpAID09HTMnTtXzl7z8JQ8vGjwyMWLFy/Qs2dPVjoVyH1rHj16NF68eIF+/fqxffNW0ROVQhWxdOnSfM06JS0aBaVCl4aKigpGjhzJWXfo0CH07NmTpVeXhRUrVqBatWoAgOPHjyMwMFDmY3l4SgNeNHhkIjk5GfPnz4elpSUuXLjA1tva2uLu3bvYu3cv9PX1ORO60uIv2rRpwx623759YzmZ8lKSopGTk4OrV68CACpXrgxra2uZjhOP1RCZma5cuYL27dsjLi5OpjYqVaqEdevWse/Tpk2TqFrIw1OW4EWDp0CEQiH2798PU1NTbNy4kT3QjIyM8L///Q/BwcFo0aIF218UMQ1IFw0AWLduHXR1dQHkmnVEZVXFKUnRCAsLQ1JSEgDAwcGBCUBhiCct7NmzJ5vof/z4Mdq0aSNzNtuRI0eiVatWAIDnz59jx44d8nSfh6dE4UWDJ19CQkLQqlUrjB49mhVM0tTUxJIlSxAZGYkhQ4ZIlHkVF4285ikR+vr6WLlyJfs+ZcoUTl4noGRFQ17TlAjxkQYRISQkhKVXj42NRdu2bXH9+vVC21FRUcH27dvZvVy+fHmBNTp4eEoTXjR4JIiLi8PQoUPRtm1bhIWFsfXOzs6IiIjAqlWrpBYmAlCoeUrElClT0KhRIwC5b/riqdCB0hMN8aC+wqhevTp70MfHx8PMzAyhoaHMvPXt2zd07doVR48eLbStli1bYsyYMQByTYELFy6U5xJ4eEoMXjR4GD9+/MCaNWtgamqK//3vf2x9o0aNcPXqVfj6+hYazS3LSAPIjYXw9PRk3xctWsSC5YCSy3KbkpLCUoeYmJiwkYIsqKmpoXr16gD+L/+UgYEBrl+/zhITZmZm4o8//sDGjRsLdcl1c3NDpUqVAOTWLBf1i4enLMGLBg+ICCdPnoSFhQWWLFmCtLQ0ALkxCTt27MDDhw/RqVMnmdqSdaQBAB07dsTgwYMB5NbaXrp0KdtWUiON69evs3gReUxTIkQmqsTERBbsV6FCBZw9exZjx45l+82fPx/Tp0+XMMOJU61aNaxatYp9nzp1aoH78/CUBrxo/OY8ffoUnTt3hrOzM968eQMg1xNo6tSpePHiBSZPnswpSlQYso40RGzatIkVXNq1axcePHgAoOREQ1HTlAiRaGRnZ+PTp09svZqaGvbs2cOZu9m+fTsGDBjAuUd5mThxIpo0aQIAePDggYTZjoentOFF4zfl8+fPmDp1Kpo1a8aJDXBwcMCjR4/g6enJvIHkQZ6RBpDrhbVs2TIAuSOeqVOnQigUlliWW1FQn6qqKuzt7eU+vqCyrwKBAEuXLuWkVz99+jRLry6Nwsx2PDylDS8avxnZ2dnYsWMHTE1NsWPHDmZSqVevHk6dOoUrV66wCWpFkHekAeQm7DM1NQUAhIaGwtvbu0RGGv/99x+ioqIA5MaPiNyA5UGWuhojR47EhQsXmPNAaGgobG1t8erVK6n7t2/fHkOGDAEgabbj4SlteNH4jQgMDETz5s0xdepUfPnyBQCgra0NNzc3PH/+HH379pVwoZUXeUcaQO5IQvztev78+WxeBSg+0RBPHaKIaQqQveyro6MjgoKC2P4vXrxAmzZtOAkexdmwYQMz2+3evRsPHz5UqH88PMqGF43fgNevX6N///5wcHDAs2fP2Pphw4YhKioKixYtknlUUBiKjDSA3IeqKAVJYmIiIiIi2LaSEA1FJsEB+cq+NmvWDKGhoZz06h07dpRahEncbCcUCjFt2jS5EiLy8BQXvGj8wqSmpmLx4sWwsLDAqVOn2PqWLVsiJCQEhw4dgpGRkVLPqchIQ8TmzZuZ0Igm5YHiEY2cnBwEBAQAyE3lIR7VLg/yln2tU6cObt26hfbt2wMA0tLS0KdPH+zevVtiX3Gz3a1btzhu0Dw8pQUvGr8gRARvb2+YmZnBzc0NGRkZAHIjsffv34/bt29zMrQqE1nSiORH3bp1peaiKg7RePDgATPRderUSS4PMXEUqRVeuXJl+Pn5sfTqQqEQEydOxJIlSzijCQ0NDWzbto19nzdvnlzJEHl4igNeNH4x7t27h7Zt22LYsGHMxq6uro758+cjOjoaI0eOhIpK8f3ZxUcaipi85s2bJxFAWByioQzTFJAbzCdCnrKvovTqc+bMYevWrFkjkV69a9eu6Nu3LwAgISGB48LLw1Ma8KLxi5CQkIDRo0ejVatWnEjiXr16ITw8HOvXr1fIO0heFJ3TEKGlpYWtW7fm26ayUDTfVF40NTVRtWpVAPKJBpCbc2rTpk3w8PBgDgiHDh1Cjx49WI0SgGu28/Dw4Mz38PCUNLxo/ORkZGRg48aNMDU1xf79+9l6CwsLXL58GWfPnoWJiUmJ9Uf0gFdTU1PY5NOrVy+OwK1Zs0YpfRORmpqKkJAQAICxsXGhqVEKQ2Siio+PV2iyevr06fD19WXCEBAQwEmvXq9ePSxYsABArsv09OnT+UlxnlKDF42fFCLC+fPn0ahRI8yfPx8pKSkAgIoVK2Lr1q14/PgxunbtWuL9Epmn5J3PEEcgEEBfX599d3d3R3R0dJH7JuLGjRssDqQoowwRItHIzMxkKdblpX///ggICGABlU+ePIGNjQ3zdluwYAHLixUQEMBxbODhKUl40fgJiYiIQPfu3dGrVy+8fPkSQO6DdsKECXjx4gVmzJhRItXupCEaaRTVhVc8XiQrK0upb9fKMk2JUGQyXBpt27blpFd/9+4d2rVrh+vXr0NLSwubN29m+86aNYsTy8LDU1LwovET8fXrV8yaNQtNmjSBn58fW9++fXs8ePAAu3btYqVDSwtljDSA/8tyK5q09/Pzw9mzZ4vWuf+PSDQUTR2SF2WJBoB806sfOXIEffv2ZSL39u1brF+/vkjn4uFRBMWMzjwlSk5ODvbu3YvFixdzchbVqlULmzZtgouLS5EjuQtDKBQiOjoaYWFhSEhIQGZmJjQ0NGBgYABra2uYmppCRUVFaSMNkfmoYsWKzOQzc+ZMODo6FkmQYmNjWW3z1q1bo2LFikXqJ1Bw/ilFEKVXHzRoEC5evIjMzEwMGTIEsbGx2Lp1K5o0aYLs7GysX78eI0aMQP369Yt8Th4eWeFHGmWcmzdvokWLFpgwYQITDC0tLbi6uiIyMhIDBw4sdsEIDw+Hh4cHfHx8kJ6eDisrK3To0AFWVlZIT0+Hj48PPDw8EB4errSRhkg0dHV1WVr2N2/eYMOGDUVqV1mutuIoc6QhokKFCjhz5gzGjRvH1i1YsAA7duzAjBkzAOQ6QcyaNUsp5+PhkRV+pFFGefv2LebNm4djx45x1g8aNAgbNmxA7dq1S6Qft2/fhp+fHywsLDBo0CDOWzUA2NvbIz4+HsHBwfD19UWzZs1w+/ZtpY00RHmpmjZtiuzsbKxbtw7Dhw9X2OOpqKnQpSFr/il5UVNTw+7du1G7dm2WtHDHjh1wcnKCgYEBEhIScP78efz7778gogJHgDw8yoIXjTJGWloaNm7ciPXr13PiE5o1a4Zt27bBzs6uxPoSHh4OPz8/2NraonPnzvmOaAwNDeHi4sLScqSkpChtpKGuro6GDRti+vTp2Lx5M378+IFZs2bh9OnTcrcpFApZH3V1ddGqVasi9VFEcYw0RAgEAixZsgQ1a9bEuHHjkJ2djYsXL6JBgwawtLSEk5MTXrx4ASMjI1hZWUFTUxMZGRmIiYmBj48PdHV14ejoCEtLS6X2i+f3hReNMgIR4fjx45g3bx7evn3L1uvp6cHNzQ2jR4+GqqpqifVHKBTC398fFhYWBQqGCIFAgM6dO+Pz589wcnLC06dPi3R+cdEAgOXLl+N///sfEhMTcebMGVy6dImVVJWVhw8fstoUDg4OCseR5KU4RUPEyJEjYWhoCGdnZ6SmpkJPTw/dunWDubk57OzsCh0BpqSkwMbGplj6xvN7wY9bywAPHz5Ehw4dMGjQICYYampqmDVrFl68eIFx48aVqGAAQHR0NJKTk2FnZyfznIlAIED79u2hra3NibNQhLyioauri40bN7LtM2bMYDm1ZKU4TFMAUL58eRaMWFyiAfxfevW2bduiW7dusLW1xcCBAyUEQ4RoBGhraws/Pz+Eh4cXW994fh940ShFPn78iAkTJsDa2hpBQUFsfdeuXfHkyRNs3rwZlSpVKpW+hYWFwcjIiPMWLQuGhobQ19cvkmgIhUJWHEo83mTo0KFo164dgNx6FFu2bJGr3eKYBBchuk/FKRoA0KRJE/Tt2xfm5uZyjQDNzc3h7+/P7isPj6LwolEKZGVlYevWrTAxMcGePXtY0FqDBg1w7tw5XLp0idVcKC0SEhJgbGys0LFmZmYoX768wufOr2qfQCCAp6cnm9hdtWoV3r17J1Ob379/R3BwMACgfv36Cl9bfoje9r9//86i84uD6OhofP/+He3bt5drBGhnZ4fk5GS8ePGi2PrG83vAi0YJ4+fnhyZNmmDWrFksKZ2Ojg42bNiAZ8+eoWfPnsXuQisLmZmZ0NTUVOhYRY8TUVCp12bNmmHSpEkAcp0G5s6dK1Ob4qlDlGmaElES8xpA0UaARkZGuH//fjH1jOd3gReNEuLFixfo3bs3unXrxoLLAGDUqFGIjo7GvHnzivywLSo/fvzA2bNnMWLECKSkpMg9ZyAiIyOjSMJXWH3wlStXQk9PDwDg4+ODa9euFdpmcZqmgOJzu81LUUaAxsbGSExMVHKPeH43eNEoZpKTk7FgwQJYWlri3LlzbH2bNm1w9+5d7Nu3j1OToaRJTU3F8ePHMXjwYFSrVg19+vTBoUOH8O7dO0RFRSnUZlRUVJHyRBUmGlWqVMHatWvZ92nTpnGOkYZoElxFRYUFCyqTkhppFHUEqOiLAA+PCF40igmhUIgDBw7AzMwMGzZsYA81Q0NDeHt749atW2jZsmWp9O3r16/w9vZGv379UK1aNQwcOBA+Pj5ITU1l+zx9+hSJiYlyvzXHx8cjMTGxSAFlhYkGAIwePZrdv/DwcGzfvj3f9t69e4fnz58DAFq1alUszgUlJRoaGhpFGgGW9miW5+eHF41i4Pbt27CxscGoUaOQkJAAIPctb/HixYiKisKff/5Z4vMWnz59wt69e+Hk5ITq1atj2LBhOH36NKfSXuXKlTFy5EicO3cOt27dgq6uLoKDg2UeNRARbt68idTU1GKZCBdHRUWFIxTLly9n9zovooA+oHhMU0DJiYaBgQFiYmIUOjYmJqbIrtA8PLxoKJH4+HgMGzYMbdq0wb1799j6/v374/nz51i9ejUqVKhQov3ZsWMHOnXqBH19fYwdOxaXLl3iPJSrV6+OCRMmwN/fH4mJidi/fz969uyJ8uXLw9HREREREQgICChUOIgIAQEBiIqKwqVLl4oUES6LaAC5o4YxY8YAyI1CFxUqyouyU6FLQ9lJC/PD2toacXFxCo0A4+Li0KJFi2LqGc/vAh8RrgR+/PiBzZs3w83NDd+/f2frGzVqhK1bt8LBwaHE+vLff//hxIkTOHHiBEJDQ6U+7GvWrIn+/fvD2dkZbdu2zTdw0NLSEikpKfDz88OXL1+kRh4DuQ+kmzdvIioqCpcvX0Z4eDiys7MVvgbxGtmF1QVZu3YtTpw4ga9fv+LQoUMYP3482rZty7YLhUI2Ca6jo6O01CF5KamRhqmpKRsByprdmIgQFBSEihUrlmgVR55fE140igAR4fTp05gzZw5ev37N1leuXBmrVq3ChAkTlJaqoiCio6OZUISFhUndx9jYGM7OznB2dkbLli1lNo/Z2Njg1KlTCAsLQ2RkJGrUqAETExM2qRoVFYXExERkZ2cjMDAQt2/fBgB4enpi7NixCpmpZB1pAEC1atWwevVqTJ06FQAwdepU3L9/nwnh48ePWXbgTp06FVtxKh0dHZQvXx5paWnF6j2loqICR0dH+Pr6IiAgoNAAP9EIMDIyEgMGDOCTF/IUGV40FOTZs2eYOXMmrl69ytapqKhg0qRJWLFiBapWrVps5yYiPHv2jAmFqCRoXho2bMiEokmTJgrNoyQnJ2Pnzp34/v07LCwsMGfOHDx8+BAZGRnQ0NBAZGQkgoKC8OrVK0yYMIHV3n758iWGDBmCEydOyJ0CRR7RAIAJEybAy8sLjx8/xqNHj7Bnzx4Wy1ESpikgN4CuRo0aiImJKfaocPERYFJSEtq1a5fvCDAoKAiRkZHo2rUrn7SQRynwoiEnX758wfLly7Fz507k5OSw9Z06dcLWrVvRuHHjYjkvESEsLIwJRX6Rvc2bN2dCYW5uXuTz7tu3j0U4t2nTBqNGjeJsX7hwIXPNzeuie+bMGUybNg07duyQS7DERUNDQ6PQ/dXU1LB9+3aWAXjx4sVwcXGBnp5eseWbkoZINL59+4b09PQiZ/otCBsbG+jo6MDf3x9eXl4wMjKCsbExJ8ttXFwcdHV1MWDAAF4weJQHSWHWrFnSVv/WZGVl0Y4dO6hKlSoEgC316tWjkydPklAoVPo5c3JyKDg4mGbNmkV16tThnFd8sbGxoY0bN1JMTIxSz5+dnU316tVj53n27JnEPlFRUWx71apV2WdVVVX22c3NTa7zXr9+nR07f/58mY8bOnQoO278+PH0/ft30tDQIABUt27dYvkbiePi4sLOr+y/RX7k5ORQZGQkeXt7k7u7O7m5uZG7uzt5e3tTZGQk5eTklEg/eH5d8uoBLxoyEBgYSI0bN+Y8qMuXL09r1qyh9PR0pZ4rKyuLrl69SpMnT6YaNWpIFQkVFRXq0KEDbdu2jWJjY5V6fnFOnDjBzuno6JjvfnZ2dhJ9XL58Oef7oUOHZD7vlStX2HGLFy+W+bj4+HiqUKECASCBQEAeHh4cESluZsyYwc4XHBxc7Ofj4SkJ8uoBb54qgNevX2Pu3Lk4efIkZ/2ff/6J9evXw8jISCnnyczMxNWrV3HixAmcOXOGUwdchJqaGjp16gRnZ2f07dsX1atXV8q5C0I8i2xBZUXHjBnDydIL5LoZa2pq4q+//gKQG4xnYGAgk4lI3jkNETVq1ICrqyvmzp0LIuJEjRe3aUp0fhHFPa/Bw1NqyKIsvxupqam0ePFi0tTU5Lwtt2jRgm7duqWUc6SlpdGpU6do6NChVLFiRakjCk1NTerVqxcdOHCAPn/+rJTzysq9e/dYPxo2bFigaSc1NZV0dHQ4fY+OjiahUEiTJ09m63R0dOjhw4eFnvvMmTPsmDVr1sjV78zMTLKwsJAYmZXE/Tt48CA7p4eHR7Gfj4enJOBHGgVARPj333+xYMECxMXFsfX6+vpYu3YtRowYUSSXxZSUFFy8eBEnTpzAxYsXOTEdIsqXLw8nJyc4OzujR48e0NHRUfh8RUF8lDFz5swCJ7K1tbUxePBgeHl5sXXlypWDQCDAtm3bEB8fj9OnTyMlJQXdu3fH7du3UadOnXzbU3SkIdp/27ZtnJFF8+bNUaVKFbnaUQR+pMHzO8CLxv/n/v37mDFjBnMZBXIfQDNnzsSSJUtYZTZ5SUpKwtmzZ3HixAn4+/tLzRukq6uLXr16wdnZGV27di1SCg5l8O7dOxw7dgxAbrnZoUOHFnrMmDFjOKIh8hxSVVXFv//+CwcHB4SGhiIhIQHdunXDrVu38n2QF0U0AKBz585o0aIFSwNeUrEJvGjw/A789qKRkJCAv/76CwcOHOBET/fs2RObN29WKIL2w4cPOH36NE6cOIHAwECp0dFVq1ZF37590b9/fzg4OJSpRHLbt29nfZ44caJMrqOtWrWCtrY2Gz29ffuWpS/X0tLCuXPnYGtri+joaERGRqJPnz64cuUKypUrJ9FWUUUDyI16F4nG/fv38eTJEzRp0kShtmSFFw2e3wJZbFi/IhkZGbRx40YJW7y5uTldunRJ7vbevXtH27Ztow4dOpCKiorUOQoDAwOaPHkyXb16lbKysorhqopOamoqVa5cmQCQuro6xcfHy3xs3bp12bXOnTtXYvurV69IX1+f7ePs7EzZ2dkS++3du5fts3v3brmvIScnh6pXr86593Z2dsXucisUCpmLb+PGjYv1XDw8JQXvcktE58+fJxMTE85DpWLFirRlyxbKzMyUuZ1Xr17Rxo0bycbGJt8Yitq1a9OsWbMoODj4p/CZ37FjB+v78OHD5TpW3C1ZX19f6r28f/8+aWtrs/2mT58u8TDftWsX275v3z65r+Hhw4cc12jR5//9739ytyUvongaPT29Yj8XD09J8FuLRkREBHXv3p3zUBcIBDR+/HhKTEyUuY3Vq1dT8+bN8xUKExMTWrhwId27d6/Y326VSU5ODkdMZfF0Eqdhw4ac+3DmzBmp+126dIkT/Ldx40bOdk9PT7bt8OHDcl/Hhg0b2PETJ05kn2vUqEHJyclytycP4i8QGRkZxXouHp6S4LcUjaSkJJo1axapqalJmCwePHhQ4LFCoZAePXpES5culXgoii+NGjWi5cuX05MnT34qoRDn3Llz7Hrs7e3lPl48ehwA9e7dO9999+/fz9lXfBTg7u7O1h89elTufnTu3JkdHxUVRb169WLf582bJ3d78tCvXz92rv/++69Yz8XDUxL8VqKRnZ1Ne/bsoWrVqnEeULVq1aKjR4/m+3AXCoV0584dmj9/PhkbG+crFNbW1uTm5kZRUVElfGXFQ6dOndi1nT17Vu7jRRHsolGEqqpqgXMiK1euZOdTV1enq1evEhHRunXr2PoTJ07I1Ye0tDQWX1O7dm0SCoX08uVLtk5NTY0iIiLkvjZZEY9LuX37drGdh4enpMirB79snuSgoCC0bNkS48ePx8ePHwHkxg4sX74ckZGRGDRoECf2ICcnB0FBQZg5cybq1KmD1q1bY8OGDRJV0mxtbeHu7o7Xr1/j/v37WLRoEUxNTUv02oqDx48fIzAwEABgYmKCHj16yN1Geno6AKBixYoAcu/poUOH8t1/yZIlGDduHIBcj6l+/frhyZMnRfKeCgoKYm7Njo6OEAgEMDY2xvz58wEA2dnZmDZtWpFqmBcE70HF86vzy4lGbGws/vjjD7Rv3x4PHz5k6wcOHIioqCi4urqyOIisrCwEBARg0qRJMDIyQvv27eHh4YHY2Fh2nIqKCuzt7bF9+3bExcXh1q1bmD17NurWrVvSl1asiAfzzZgxQ6HYBpFoiKc42bdvX74PaIFAgL///hs9e/YEkJuG3cnJiZNGRZYst+Lklwp94cKFqF27NoDc8q95U8Moi5Kq4MfDU2rIMhz5GUhLS6MVK1aQlpYWx4TUtGlTunHjBtvvx48fdO7cORo1apRExlqImUq6detGXl5e9OHDh1K8qpLh/fv3zFW0UqVKlJKSIncbQqGQ3T8bGxuyt7dn34OCggo8NjU1lVq1asX219PTY59FJitZadKkCXNw+PTpE2ebeALGWrVq0ffv3+W+zsK4ePEiO8fSpUuV3j4PT0nzy5mniAjHjx+Hubk5li9fzt52q1atil27diEsLAwtWrTAiRMnMGTIEFSrVg29evXC/v378eXLF9ZOuXLl0KdPHxw6dAgfPnzApUuXMHbsWFSrVq20Lq3E+Pvvv1mJ1fHjxytUx/zHjx/sc7ly5TB69Gj2fe/evQUeq62tjXPnzsHY2BgAOCMNecxT79+/x5MnTwAALVq0kCiE1a9fP5ZeJDY2lpPQUFnw5imeX50yFREuFAoRHR2NsLAwJCQkIDMzExoaGjAwMIC1tTVMTU05ZpPHjx9jxowZuHHjBlunpqaGqVOnYubMmbh16xYGDhyIS5cuMTERp0KFCujRowf69+8PJycnhR6WPzvp6enYuXMngNyUH6KyqfIiLhpaWlpwdnbG1KlT8e3bNxw7dgweHh4FpmKpXr06Ll++DFtbWzYHJeqTrAQEBLDP0qr0CQQCeHp6onHjxsjKysKGDRswYsQINGjQQOZzFIa4aBRn2VcentKizIhGeHg4/P39kZycDCMjI1hZWXGqkPn4+EBXVxeOjo7Q19fHkiVL4OXlBaFQyNqwt7dnOY5MTU3Z27M4FStWRO/evTFgwAB06dKlWKur/Qz873//Y2/2AwcORK1atRRqR1yUy5UrBy0tLQwZMgQ7d+5EWloajh07hrFjxxbYRoMGDXD+/Hm0bduWpTH5+++/YWtrK1Mfrly5wj7nlwrdzMwMs2bNwoYNG5CZmYlZs2bh3LlzMrUvC9WqVYOqqipycnL4kQbPr4ksNqziJjQ0lFxdXcnHx4fi4uKk7hMXF0dHjx4lV1dXjr0cAFWrVo2aNm2ab/oOPT09Gjt2LF26dIkPuBJDKBSSpaUlu093795VuK2YmBjWzpAhQ4goN/obYvMcstK1a1fO32/Lli2FHiMUClmKEm1t7QL/zsnJyWRoaMjaP3funMx9kwVR2wYGBkptl4enNChzcxrh4eHw8/ODra0tXFxcON4n4hgaGmLgwIGwtbVFhw4dYGlpyUwXHz9+xOPHjzmjDkNDQ0ydOhXXrl3D+/fv4eXlhW7dusntjfMrc+XKFYSHhwMA2rZti5YtWyrcVt6RBgBYWVmxJIG3b9/G8+fPZWpL3MQDALNnz8bx48cLPObp06dITEwEkDviLOjvrKOjg02bNrHvM2fO5JjXioqo/x8+fODUkefh+RUoVdEQCoXw9/eHhYUFOnfuXGDNBiDXJt25c2eYmZnBycmJIxIAULduXcyZMwchISGIjY2Fp6cnOnbsCDW1MmOFK1Ns3ryZfS6oMp8s5J3TAHL/XmPGjGHrC5sQFyEepwHkOjsMHToUN2/ezPcYWUxT4gwePBjt27cHAMTExMDd3V2mvsmC6MVHKBTiw4cPSmuXh6csUKqiER0djeTkZNjZ2RUqGCIEAgHat28PbW1tmJqawszMDH/99RfCwsLw6tUrbNq0CW3atCmxGgo/K8+fP4efnx+AXLHt27dvkdqTNtIAckvjit76Dx8+LHWeKS/iojFw4EAAuSVx+/Tpw0ZGeckvPiM/RJPiotHqmjVr8N9//xV6nCzwHlQ8vzKl+mQNCwuDkZGRhDmiMAwNDWFgYIDJkycjLCwMa9asgZWVlczCwwNs3bqVfZ4+fbpcXkrSkDbSAHJdn/v16wcg14x4/vz5QtsSF40NGzagW7duAICvX7+ie/funKqKonOLRiG1atWCmZmZTH1u0qQJpkyZAiBX9ObMmSPTcYXBe1Dx/MqUqt0mISEBVlZWCh1ramoKPz8/VKhQAVpaWtDT05N5qVq1apkqelTSfPr0CYcPHwaQa98XNyEpSn4jDQAYPXo0fHx8AOSaqPr3719gW+KiUb58eRw/fhwdO3ZEWFgYYmNj4eTkhJs3b7J0JcHBwUy0unTpItfLw4oVK3DkyBF8/PgRJ06cwJUrV2QybxUEP9Lg+ZUpVdHIzMxU+OGtqanJAr/S09MRGxvLSf9RGDo6OnIJTZUqVX6ZuZFdu3axh+zYsWMVLmUrjrho5HVj7ty5M2rXro23b9/i8uXLiIuLg5GRUb5tiZuw1NXVUaFCBVy4cAFt2rTB69ev8eTJEzg7O+PixYvQ0NCQ2zQlTqVKlbB+/XoWjDh9+nQ8fvy4SA4TvGjw/MqU6lNQQ0NDas1sWcjIyGBvpAKBAOrq6sjOzpaYHM+PlJQUpKSk4PXr1zKfs3LlynIJTaVKlcrc3EpGRgZ27NgBIDev1vTp05XSbn7mKdF5Ro0ahRUrVkAoFOLgwYP466+/8m1LWsJCfX19Fvz3+fNnXL16FaNHj8ahQ4eYaAgEAjg4OMjd9xEjRmDPnj24ffs2IiMjsW3bNsydO1fudkTwosHzK1OqomFgYICYmBjY29vLfWxUVBSzFxMR5+1UR0cHzZs3h4WFBerUqQN1dXV8/vwZnz59klg+f/4sc8bTpKQkJCUl4cWLFzLtr6KigqpVq8olNDo6OsU6N+Pj44OEhAQAuWk1lJV4sSDzFACMGjUKK1euBBFh3759WLhwYb6Cml+WW1NTU5w7dw6dOnXCjx8/8L///Q+VK1fG48ePAeS6+IrqksuDiooKtm/fjpYtW4KIsGLFCgwZMiRf9+/C4JMW8vzKlKpoWFtbw8fHB/Hx8XL9QOPj45GYmAg7Ozuoq6vj6tWrHM+XlJQU3Lx5k02OGhoawsHBgS01a9Zk++bk5ODr169SBSW/5evXrzL1UygU4uPHj5y0GIWhrq4ul8jo6emxrL2FQURKdbMVp6CRBgDUqVMHDg4OCAgIQExMDG7evImOHTtKbaug1Oht2rTB0aNH0b9/fwiFQmzfvp1tk9c0JY61tTXGjx+P3bt3IzU1FfPnz4e3t7dCbenr60MgEICIeNHg+eUoVdEwNTWFrq4ugoOD4eLiItMbNhEhKCgIFStWxJgxYzBu3DgQEV69eoWrV68iICAAgYGB+Pz5MzsmPj4ehw8fZpO/pqamcHBwQOfOndGxY0dUrVoVVatWldnrJisrC1++fJFLaFJTU2Vu+/3793I9bMqVKyeTuLx+/Zq9lbds2VLm9ByyUNhIAwDGjBnD8kPt3bu3UNFQU1OT+n+iT58+2L59OyZPnsxZXxTRAHLdbo8fP44vX77gf//7H8aPH89iOeRBTU0N1apVw4cPH3jvKZ5fjlIVDRUVFTg6OsLX1xcBAQGFBvgREQICAhAZGYkBAwYw84ao0I6xsTHGjx8PoVCIJ0+e4OrVq7h69Spu3LiBtLQ01k50dDSio6Oxc+dOCAQCWFlZoXPnznBwcEDbtm0LfXNXV1eHvr4+9PX1Zb7WHz9+5Gsik7Z8/PhR5vmeHz9+4N27d3j37p3M/Xn69Cnq168vl8dZQY4AhY00AKBv376oXLkykpKS4Ovri+3btzMPKHFEolFQhttJkybh7du3WLduHVsnq5kxP6pWrYo1a9Zg0qRJAIBp06YhLCxMIQeIGjVq4MOHD0hISIBQKCxzc1s8PIoiICm/tNmzZ3PMGMXN7du34efnBwsLC7Rr106qqSo+Ph5BQUGIjIxE165dYWNjI3P7mZmZuHPnDhOR27dvs4R4edHQ0ICtrS0bibRo0aJUvKaICGlpaXKNZj59+pTvdSmDSpUq5Ssq169fx+XLlwEAhw4dgpOTEypXrizxsJw+fTo8PT0BADt37sTEiRMlzmNhYYHIyEjo6uri27dv+fbn6dOnLE0JkOuoEBISAnNzc4WvMScnBy1btmQFvDw9PRXK/Nu9e3d2Pz58+PBbpNjn+TXJqwdlQjQAySy3xsbGnCy3cXFxLMutpaVlkc6VkpKCoKAgJiIik400dHV10aFDByYiDRs2LLNBhESE5ORkqWLy77//4sGDBwByI8DLlSsntyOAvKioqKBKlSoccREIBDh16hTrx/bt2znbdXV1YWJigpiYGFStWpVTWyMvmzdvlgjIq1OnDkJDQ+UOGBUnJCQEbdu2BZCbFTk6OppTjVAWRo8ejf379wPITeEvLm7yIm/JAB4eZVJmRQPI/XG8ePEC9+/fR2JiIjIyMqCpqQl9fX20aNECJiYmxfLj+PDhA65du8ZE5NWrV/nua2BggE6dOjEREZUQLcskJSWhZs2aSEtLQ/ny5fHu3TtUrlwZQPE6AiiCmpoahEIhhEIhNDQ00Lt373xHN3PmzGG1VMzNzREZGQkAaN68OW7cuAEdHR2F+zFy5EgcPHgQQK4AyJo3S8SSJUuwZs0aAMDly5fRtWtXhfpRki9TPzO8sBYfZVo0ygqvX79mAhIYGFhg0rkGDRowryx7e3uFXD6Lmw0bNmDBggUAgClTpnA8jhRBmiPAxo0bcefOHQBA7969kZmZqZAjgKLUqFEDnz59YvMhtWrVwsiRI6Gvry9VcAoLKk1MTISpqSmSk5MB5JpQW7duLXN/duzYwcxa+/fvx8iRI+W+JlnNtsHBwYiIiJDbbPurwAtr8cKLhpwQEZ49e4aAgAA2qZ7fA1AgEKBZs2ZMROzs7KCtrV3CPeaSlZWFevXqIS4uDgKBAFFRUTAxMVH6eVxcXODr6wsAePv2rUQxJ3FHgDdv3sDFxQVZWVnQ0tLCyJEjkZSUxATmyZMnMgdpKkqFChUKnfy/fv06E1grKyvcvXtX5hxdJ0+ehLOzM4Bcr6yCghmlER4eDl9fX9ja2srsIBISEoIBAwb8Vg9GXliLn7x68GvkxShGBAIBGjdujMaNG2PWrFnIysrCvXv3mIiEhoayt1siwsOHD/Hw4UNs2rQJ6urqaNOmDRORVq1ayVXzWhn4+vqyBH89e/YsFsEACk4jAuS64RoZGcHIyAhNmzaFi4sLjh49itq1a7Pa4CKTwvPnz3Hr1i0QEfz9/aWayM6fP49Hjx4ByB1VZGVlyeUIkJqaitTUVLx580am/R88eABdXV0YGhrKHTsjb6yGoiUDvnz5wo77HUwx4rV4CrpPhoaGcHFxQUBAAPz8/KCjo/NbCauy4UVDTtTV1WFrawtbW1ssW7YM379/R3BwMBORR48esYnlrKwsFmS4fPlyVKhQgU2qOzg4oFGjRsX64yYibNmyhX1XZjBfXsRdbvOL0xCnd+/eMDIygra2NipUqABTU1NmUtDW1kbt2rWRkZGB1NRUWFtbSxx/4cIF9jksLAzVqlVjjgDe3t4cjydnZ2eYmJhIFZ8vX77IPKpJS0vDy5cv8fLlS5n2F3Hw4EE8evRIJrHR1dVlJQMGDx4sV8kAOzs7eHl54cWLFzLHHP2s8MJaevCiUUS0tbXRtWtXNtH5+fNnNqkeEBDAecCkpqbiwoUL7IFXrVo1TqR6vXr1lNq3kJAQ3Lt3DwDQtGnTfIPplEFhIw1xRDmerK2tYWdnJ2FSsLe3Zy7Wvr6+SElJ4ZgUPnz4wFxiraysmDurQCBAxYoVMWXKFAiFQpZX69SpUzh16hR69+4t0RdZHAH8/f1ZkJ5I2OQhJSUFwcHBMu2rpqaGkSNHokWLFgqVDDAyMsL9+/d/edHghbX04EVDyVStWhUDBgzAgAEDAOTa90WT6gEBAawkKZBbX+Lo0aM4evQoAKBevXosyLBTp05F9u0XH2XMnj27WF2FRSMNdXX1Au3+8pgUBg4cKNWkcPXqVbZffmnMp02bhtjYWGzcuBFCoRCDBw9GYGCghD1bVVW10IwA7969g7m5Ob5//46srCzcvXsXderUKdTLzN/fHzk5OSyliCxkZ2dDT08PpqamMu2fF2NjYyaovzJFqcXzuwhrccGLRjFTu3ZtjBo1CqNGjQIR4fnz50xErl+/zrxzgFyvLS8vL3h5eQHILRIkcu1t3749KlSoIPN5X79+zeIhDAwMMHjwYOVeWB5EI42CTFPKMinImgp93bp1ePfuHY4cOYL09HT06tULISEhcs/r1KxZE0uXLsXChQshFAoxc+ZMBAcHFxq70ahRI4SHh0NTUxNJSUkyp55RV1cvUskARTNH/0wUpRbP7yKsxQUvGiWIQCCApaUlLC0tMX36dGRnZ+P+/ftMRG7dusXJ1vvkyRM8efIEW7ZsgZqaGlq3bs1EpHXr1gXWfPD09GS2+ilTpihcH0JW/3fRSKMg05QyTAqmpqZMNLS0tFgQnjRUVFSwf/9+JCQk4Nq1a/j06RO6deuGkJAQuVLAAMDMmTOxb98+REdHIyQkBIcPH8bw4cMLPKZGjRoIDw/Hjx8/kJ6eDkNDQ5kSc7q7uxepZMDvUGCsqLV4fgdhLS74maBSRE1NDTY2Nli8eDECAwORlJQEf39/LFiwAC1atOA8WLOzs3Hr1i2sXLkS7du3R5UqVdC9e3ds2rQJjx494kzmJicn459//gGQ++YvLVWHLISHh8PDwwM+Pj5IT0+HlZUVOnToACsrK6Snp8PHxwceHh4IDw+XaaShDJNCREQEm1/o0KFDoQ8OTU1NnDp1Co0bNwYAvHr1Cj179pQ7bkRTUxPbtm1j3+fPn19gihNA8boaopIBihATEyO3IP5MCIVCREZGgoh4YS0l+JFGKSPtTb5atWqYOXMmzMzM8N9//yEwMBBXr15FVFQUO+779++4fPkyy2+kp6cHe3t7ODg44L///kNKSgoAYNiwYQoFHIr7vw8aNCjfyerg4GD4+vrCwsICCQkJBY40lGFSUKRKX8WKFXHx4kW0adMG7969w/379zFo0CCcOXNGrrxiXbt2Rd++fXH69GkkJiZixYoVBcYz5RWNhg0bynSeopQMiIuLK3ZTZGkhHsRXrlw5vHz5UqFaPL+6sBY3/EijFCnsTf7ChQt4+/YtJk+ejMjISMTGxuLAgQMYNmyYxMPk06dPOH78OCZOnIi1a9ey9Q0aNOBMvsvaL9FktYuLS74PLpH/u62tLTp06ABLS8sCRxrKMCkoWtq1Zs2auHz5Msuqe/HiRUycOFHuvFtbtmxh17ht2zaEh4fnu6+iI43Xr18jLS0NQUFBMvdPvGRAccXilCa3b9+Gr68vDA0NMW7cOPTp0wfx8fFyp54XCWuLFi2Kqae/PrxolBKiH4GRkRHGjRuHsWPHwt7eHra2trC3t8fYsWMxbtw4GBkZwdfXF7dv30bNmjUxYsQIHDp0CO/evUNERAQ8PT3Rt29fqSnGAWDBggUwMDBA48aNMXPmTJw7d44z+Z4XRSerzczM4OTkVOBIo6jlfTU0NFiuKUNDQ5nf3EVYWlrizJkzbH5n7969WLlypVxt1K1bF4sWLQKQ6647bdq0fB/s8lbwIyJs2rQJPXv2xIULFxAZGYmAgIBChUO8ZECXLl1+ufgD8ZeYgQMHwtDQkFOLhxfWkuXX+t/1k6DIm7yfnx/nrVYgEMDc3BxTp07FqVOn8PnzZ+YKKo1nz57Bw8MDvXv3RpUqVWBra4ulS5fi+vXrnAe5aLLazs5Orsnq9u3bQ1tbG0ZGRvnuV1RbvYaGBquL0qVLF4VciDt06IBDhw6x766urmz+R1bmzZvHYmquXbuG48ePS91PnpFGeno6hg8fjnnz5kEoFCI8PBxxcXEICQnB8ePH832jjo+Px7FjxxASEoKuXbv+cpHOQqEQfn5+MDc357zEiGrxRERE8MJawvBzGiVMcUWyimIjRGVvLSws4OnpicDAQAQEBOD+/ftssjwnJwehoaEIDQ3F6tWroaWlBTs7Ozg4OKBChQoKT1br6+sXOIopqq1e3LOsKFX6Bg0ahLi4OJZWfeLEiTA0NISTk5NMx2tpaWHr1q3o06cPAGDOnDlwcnKScImWVTTi4uLQr18/FogJAMuWLcPy5csREREBf39/eHl5FZiM71fMOUVEOHToEFJSUtC+fXuJ34qlpSVSUlLg5+eHpKQkmWvx/Gr3qaThRaOEKc5I1rzBfKJI8zVr1uDr16+4ceMGCzKMiIhg+6anp8Pf3x/+/v5YuHChwg9kMzOzAh+ORS3vK16zu3Pnzgr1UcTs2bMRGxuLrVu3IicnBy4uLrh+/Tpatmwp0/G9evVC9+7dcenSJbx79w5ubm5wc3Pj7CMuGvmNFG7fvo1+/fohISEBAFC+fHkcOnSIJTu0tLSEhYUFKxnw8OFDTsmAwYMHF1vJgNLkv//+w7Rp01CpUiXY2trm+xJjY2MDHR2dfIX1xYsXeP/+/S8rrKUBLxolTHFFssbGxjIziZ6eHv7880/O9kqVKqFPnz7s7Tg+Pp55ZV29ehWxsbEAct2AizJZLRAIkJOTIzUqvCjlfR0dHTF79mwAQLNmzeQuiiQNd3d3xMXF4fjx40hLS0OPHj0QGhrKEigWhEAggIeHB65evYrMzExs2rQJI0eO5ERya2trQ0dHBykpKVLF9ODBgxg/fjwbQdWpUwdnzpxB06ZNOfupqKjAzMzst4hgzs7OhoeHB5YtW4a0tDQsXLiw0OvOT1hF/xd/VWEtLXjRKGGKK5J1+/btLMPrpEmTCs3/ZGhoiKFDh2Lo0KEgIrx48QJXr15FQkJCkSarf/z4gRo1aqBv375wdnaGvb09J7BQHpPCzZs3ERUVha5du+LNmzfMbp1f6hB5UVFRwaFDh5CYmIibN2/i48ePLPhPlhQuJiYmmDNnDtauXYusrCzMmDEDFy9e5AhhjRo1JEQjOzsb8+bNw9atW9m6Dh064Pjx4791Wdg7d+5gwoQJnEqasr7ESBPWkJAQ3Lhx47cQ25KEl94SpjgiWVNTU7Fnzx4AuR5KkydPlqtdgUAAU1NTTJo0CTVq1EB0dLRC/YuKikJ8fDw+fvwILy8vdOvWDfr6+hg+fDjOnDnDAgBtbGwwYMAAxMXFwcvLC7t27cK1a9cQEhKCa9euYdeuXfDy8kJUVBQGDBgAGxsbXLlyhZ2nKPMZeSlXrhxOnz7NPLFevnyJXr16sQn3wli8eDFq1qwJILdC39mzZznbRSNKUSr2L1++wMnJiSMYkydPxpUrV35bwfj27RtGjhyJNm3aSJRezs7O5oP4yhi8aJQwRXU7zcjIgK+vL75//87WHzx4kJVg/eOPP2BgYCB32z9+/MDixYvh6emJhIQEhfzfExMTcffuXY4Z4OvXrzh8+DD69u2LatWqYeDAgfDx8UHt2rUxY8YMvH37FiEhIfDz88P169dx584dhISE4MiRI/jx4wcsLS1ZXQ0g9yHfrl07ua+vICpXroxLly6xEc+dO3cwePBgmWpzaGtrw93dnX2fOXMmJ+Ov+CgqKCgIrVq1YgKopqaGXbt2YceOHSVeZ6U0ISJERERgz549aN++PapWrYqDBw9K9YCKi4vjBLXKAx/EV0yQFGbNmiVtNY8S8Pb2Ji8vL4WO3blzJw0bNowAkJaWFvXv358OHz5M9evXJwAEgB49eiR3uzdv3iQzMzMCQCoqKjRv3jw6evQoCYVCmY4XCoV05MgRmjt3LgkEAtaXghZNTU3q1asX1a1blwCQQCCgjIwM8vPzY/ssXbqUiIieP3/O1jk6Osp9fbLy6NEj0tHRYeeaMGGCTPdAKBRSp06d2HGurq5s2+zZs9l6LS0t9rlatWp08+bNYruWskRmZibduXOHNm3aRH379iU9Pb0C/28IBAJq3rw5TZ8+nfbu3Uuurq4UFxcn1znj4uLI1dWVIiMji+mqfh/y6gE/0ihhrK2tERcXV6Q3eSDX4+nkyZMYNmwYXr16BSDXzTZvmdWCSE5OxuTJk9G+fXv2Nqeqqory5cvLHVgWFRWFS5cu5RtkmJeMjAycO3eOVc7T1NTE/v37OdHrorfv4jJN5aVp06Y4deoUO+/u3bslPKKkIRAI4OnpyVKSrFu3Dq9fvwYAzqhPNAJp1qwZ7t27Bzs7O2VfQpkgNTUVV69ehaurKxwcHFCpUiW0bt0ac+fOxenTp/Hp0yeJY6pWrYqpU6fi8uXL+Pr1Kx48eAAPDw+MHDmSD+Ira8iiLDzKIycnhzZv3kw+Pj5yvckfPXqUNm/eTH5+fjR+/HiqVq2a1Lc0NTU1cnR0pN27d1NiYmK+bZ47d45q1qzJObZ169b09OlTIiIKDQ0lV1dX8vHxyfctLy4ujo4ePUqurq5kY2NDAGjTpk308uVL2r17N7m4uFDVqlVlGnlIWxYsWEBERD169GDrnjx5Iucdlx9vb29OPw4cOCDTceKjir59+9L379+pdevWnLZcXFwoNTW1mK+gZPnw4QOdPHmSZs+eTS1btiRVVVWZ/8bVqlWjY8eOFdj+s2fPyNXVlfz9/Qv9zQiFQvL39ydXV1d69uyZMi/ztyWvHvCiUQoo40eQnZ1NXl5eBf4gVVRUqGPHjuTp6cke/ImJiTR48GDOfuXLl6ctW7ZQdna2RD83b95Mrq6u5OXlRYGBgXTr1i0KDAyknTt3kqurK23evJl27NjB2vr77785beTk5NDDhw9p06ZN1K1bNypfvrxcwtGiRQtSV1cnAGRgYCCz0BaV9evXc4TYz8+v0GO+fftG+vr67DhjY2POtbRr167E+l9cCIVCevXqFR08eJDGjh1L5ubmhf4NDQ0NJe6FiooKzZw5k5KTk2U6r7wvMaGhocq87N+avHrAu9yWAsqIZFVVVUVQUBD7PmfOHBARTpw4waLChUIhrl+/juvXr2PatGkwMTHBu3fvOBO1Xbp0we7du6WWmpXm/56cnIwfP34gPj4eY8aMYUGHIvImLFRRUUGzZs3QrFkzzJkzB5mZmbhz5w6uXr0KHx8fREZGFniv7t+/zz6np6djxYoVcHZ2RqNGjYq1EuG8efMQGxvLXJmdnZ1x48aNAt2ldXV1sXHjRlZnI2/KlLp16xZrn4uDnJwcPHv2DMHBwQgKCkJQUFChptWGDRvCzs4Obdu2xZcvX+Dm5sa5F9bW1tizZ49crueFBfH96tHxZQpZlIWneJDlTX7jxo1Sh9nx8fHsDbxy5crM5CEUCunevXu0cOFCatCgQb5vf6qqqjRw4ECKjo6Wq8+LFy9mbZw5c4aIiLZu3crWHTlyROa23N3d2XHdu3enpk2byjwCqVWrFs2fP5/u3r1bbG/v2dnZ1K9fP3ZOAwMDev36dYHH7N69m+MMUKlSJfbZwcGhWPqpTH78+EFBQUHk5uZGTk5OVLFixQL/DmpqamRjY0Nz586lM2fO0MePH4mIKDo6mjp37szZV0dHh7Zt2yYxopWHnJwcioyMJG9vb3J3dyc3Nzdyd3cnb29vioyMpJycHGXdCp7/D2+eKmNI+xGsWrWKhg0bRmZmZrRs2TKpxy1ZskTC9p+XrKwsmj9/PhOX/JYmTZrQypUrKTw8vND+HjlyhB23Zs0aIiJau3YtW3fq1CmZr33q1KnsuFu3bhER0aZNm9i6wrxsREvlypVp1KhRdOPGjSI9kKSRlpZGbdu2ZecyMzOjT58+SeyXmZlJU6ZMkeibtrY2NW7cmIYNG0aLFy8mNzc32rRpE3l7e1NERESpP+S+fv1KFy9epEWLFlG7du1IU1OzwHutra1NXbp0oZUrV1JgYCB9//6d096PHz9o5cqVEu04OzvTu3fvSukqeYoCLxo/Ae/evSMVFRUCQLVr15Z4sKSlpbEHqpqaGsXGxkq08ezZMzY5LVqqV69Of/75JzVr1izfh4KFhQUtWbKEHj58KPUN/unTp2zfIUOGEBHRsmXL2LrLly/LfJ1OTk7suPj4eCIizvyI+OeKFSvKNKmupaVFXbp0oePHj1NmZqY8tz1fPn36xFySAZCtrS2lpaWx7R8/fqSOHTtKCLGlpSXNmzePXF1daefOnZyRpJeXF5sTKskJW5Hdf+rUqdS0adNCXaSrV69O/fv3py1bttD9+/cpKysr37avX78uMcdRu3ZtOnfuXIldH4/y4UXjJ6F79+7sh3flyhXOtj179kg8uEVkZGSQq6urxOhi4sSJ9PXrV7bfy5cvacOGDdSqVat8HxjGxsY0f/58unPnDhOQjIwMUlNTYw9GIqL58+ezY65fvy7zNVpYWBAAKleuHGtf3NQ1ffp09nnu3LmUk5NDjx8/ps2bN1OXLl0KfStWVVUlS0tLWr58udTRgTy8fv2aDAwMWNv9+vWj7Oxsevz4MYs1AUAaGhq0b98+unr1Krm6utLRo0cLnLj18fEptolboVBIkZGR5OXlRcOHD6d69eoVKrrGxsY0cuRI+ueffygqKkom09/Hjx9p1KhREvd+7ty5v5yn2O8ILxo/CceOHZMqDEKhkBo2bMi23bt3j20LDQ0lS0tLzo/X1NSUbty4UeC5/vvvP9qyZQu1a9cu3zfP2rVr08yZMyk4OJg97DU0NCgzM5OmTZvG9rtz545M1ycUCqlcuXJsdCNi48aNrC3xgDlp3kuZmZl069YtWrRoEZmbmxf61lytWjVycXGhK1euKDQKefDgAVWoUIG1l9cbTF9fn0JCQkrNRTQrK4vu3r1L7u7u1K9fv3zdskWLQCCgZs2a0bRp0+jYsWNyB9AJhUI6cOCAxAiwdevWCgWZ8pRNeNH4Sfjx4wdVqVKFvYknJSUREdHly5fZj7Ndu3ZERJSSkkLTp08nFRUVMjMzo2HDhtHChQtpxYoVctvP4+PjaceOHdSpUydmIsu7iB72QG7cxLhx49j3x48fy3R98fHx7BgnJye23s3Nja0XmeA0NTU55qD8SE1NpVOnTlHv3r2pcuXKhY5CmjZtSqtXr6bHjx/LPJnu5+fHRlrii7W1NcXGxhY5DkeeOY7U1FQ2onFwcCBtbe0Cr1lTU5Pat29Pf/31F126dIkz8pSXiIgICZNcxYoV6e+//1b6vBJP6cK73P4kaGpq4s8//4Snpyd+/PiBo0ePYuLEidi8eTPbZ9asWfDz88OECRNQoUIFzJkzB9ra2jAwMICpqSnHHdHHxwe6urpwdHQs0B2xRo0amDx5MiZPnoyPHz/izJkzOHHiBAICAlguph8/frD927Zty8nvU1h2XRGiiGkAqF+/PvuclZXFPosih9u3by9Tu9ra2ujbty/69u0LINdl2dPTE6dOncKLFy9YESog15X08ePHePz4MZYsWQIdHR04ODigR48ecHBwkOqCDAC2trZo0qQJHjx4wNa1adMGV69ehZaWFiIjIzn1UoRCIaKjoxEWFoaEhARkZmZCQ0MDBgYGsLa2hqmpKVRUVGSql/Lp0ycEBwcz99cHDx4UmB+rUqVKaNu2Lezs7NCuXTu0aNGiyAn8fvz4gbVr12LdunWcoliDBg3Cli1b5E75z/MTIouy8JQODx8+ZG9xLVu2pGfPnnHMRUOHDiUAZGNjU+z28y9fvtDBgwepd+/eBXpjDRgwgM6ePUvp6ekFtnf48GF2jLu7O1sv7hUmWjZs2CB3f/OSlZVF//77L9nb23NGSvkttWvXpnHjxtHRo0fpw4cPRET06tUraty4scS+6urqFBAQQETc3GIFuVRLmwj38vIib29vIsodfbx+/ZoOHTpE48aNYybBghYjIyMaPHgw7dixg548eaJ0z6yAgAAyMTHhnLNevXpyOT/w/Hzw5qmfDHFPJ2dnZ/ZZZFu3tLQscft5WFgYx8wj7QGmo6NDf/zxB/n6+kq4ZRIRrVy5ku178uRJtn7BggUSbSnbPp6Tk0PBwcE0fPjwQs1YosXY2JgjNrq6uhxnBR0dHXr06BFt2rSJAgMDZY5gFhfywMBAWr16NQ0ePJiMjIwK7ZOFhQWNHz+eDh06RK9fvy62eJXExET2giJa1NTUaNGiRVL/tjy/Frx56idj9OjRmD59OgDg1KlTbH1qaipUVFTQo0cPmJubK7XeeGE0bdqUmb7q16+PcuXK4enTp5x9UlJScOTIERw5cgRaWlpwcnKCs7MzevToAV1dXZnMUwCgr6+Pxo0by93HglBRUUHbtm3Rtm1bEBEePnyI48eP499//8Xbt2+lHpM3utvExAQtWrTAt2/fEBISgpSUFDg5OWHKlClISkrCzZs3YWtrW+DfxdDQEC4uLggICICfnx8aN27MTJF5UVNTg5WVFezs7Fi0tZ6eXtFvRgEIhULs27cP8+fPR1JSElvftm1b7N69m4+6/k3hRaOMM2TIEMydOxeZmZkcmzwADBs2DOXLl0f79u2VXm+8IFRVVdGwYUM8fPgQMTExaNWqFdt2+vRpnDp1CmfOnGE1PtLT03HixAmcOHECmpqacHR05BR6Ep8/ELeTA7m1wIuzTKdAIICVlRWsrKywdu1aPH/+HCdOnICvry+ePHmS73FhYWEICwsDkCtCQqEQ8fHx+P79O168eAELCwu5hfzFixdMNLW1tdGmTRu0a9cOdnZ2aN26NbS1tZV34YUQHh6OiRMnIjg4mK2rXLkyNmzYgNGjR/OlU39jeNEo43z69Ak6Ojr4/PkzW6enp4ddu3bhx48fSE9PV3q9cVlo1KgRHj58CKFQyMRBXV2d1SHPysrCtWvX4Ovri9OnT+Pjx48A/i8lugh1dXUcO3YMffr0QbVq1SRGGsWZCl0aDRs2RMOGDTF+/Hg4OTlxJrzzQ1zMP3/+DA0NDdjZ2ckt5JGRkdDW1sbdu3fRrFmzUinMlJ6ejtWrV2PDhg2cSfahQ4fC3d1dKbXZeX5u+NeFMkpWVhbc3NzQtGlTjmBoaWkhOjoazs7OSEhIgLGxsULtGxsbc2pXyIu4aSI5ORkAN1mhuro6HB0dsWfPHsTHxyMwMBBTpkyRELisrCyMGzcOBgYGcHBwkHi7V1Y9cHl48OABWrZsyQRDU1MTHh4e8PT0RMeOHQt8yxYIBKhRo4ZCQl6jRg3o6+ujZcuWpSIYfn5+aNSoEdzc3JhgNGjQAFeuXMHhw4d5weABwItGmeT+/fto2bIlFi9eLFEaNjMzk60rjnrjstKoUSP2WVR6Nj+3WDU1Ndjb22P79u149+6dVJu9UChEYGAgQkND2To9PT2JkUdx4+Pjg3bt2iE2NhZA7sM8KCgI06dPx9SpU3Ht2jXExsZi8eLFMDc3lxhNVKpUSeHCPyYmJkhNTS3yNcjL+/fvMXjwYHTr1o0V9FJXV8eyZcvw9OlTdO7cucT7xFN24c1TZYi0tDQsX74cmzdvZiYPkb1cRE5ODry9vTF37twi1xsvis++uGiI4jbypkWXhoqKCqpUqcK+Dx8+HDVq1ICvr6/EZPOnT59Qp04dtGrVCs7OznB2dlZ4ZFUYQqEQS5Yswdq1a9k6GxsbnDx5EhUrVsS1a9cQFBSE4OBghIaG5vtwV1NTKzUhlxehUIjdu3dj0aJF+PbtG1vfoUMH7Nq1C+bm5iXWF56fB140ygiBgYEYP34858HZpEkTVupSnP3792POnDkwMDBATEwM7O3t5T5fTEwMJyhPXmrXro0KFSogNTWVTV7LGtgnepsFcoPlJkyYgLVr1+LJkyfo2LEjmyMRcffuXdy9excLFixAs2bN4OzsjAEDBijtoZacnIw///wT58+fZ+s6deqEpk2bol+/fggLCyswiK5ixYpo27YtWrduDYFAUCQhV1VVVehYeXny5AkmTJiA27dvs3VVq1bFpk2bMGLEiJ+u7gdPycGbp0qZpKQkjB07Fg4ODkwwNDQ0sHr1avz7779MMGrVqoW2bdsCAJ4/f467d+8Wqd54XFwcWrRooXC/BQIBm9eg/1+7WZaRBiA9GlwgEKBJkyacB+6sWbPQtGlTzrGPHj3C0qVLYWFhAUtLSyxfvhxPnjyRuX50Xl68eAFra2uOYAC5Ir5lyxbcuXNHQjAMDQ0xaNAgbN++HY8ePcLnz59x4cIFLFu2DPXr15cYMclKVFQUoqKiJNyXlcn3798xf/58WFlZcQRj5MiRiIyMxMiRI3nB4CkYWYI5eIqHEydOcDKn4v/nk4qIiCAiosmTJ3Oiovfu3cu+T5gwoUh5jrZs2VLkiOExY8Zw+m5jYyPTcS4uLuyYFy9esPXR0dGc9j5//kxERC9evKB169ZRy5Yt8w10a9CgAS1cuJDu3btX4L3Iycmhp0+f0t9//00dO3YsNMkhADI3N6dx48bRwYMH6dWrVwW2HxERQa6urnIn/4uLiyNXV1cyMzOjKlWq0PPnz+U6XhbOnTtHderU4VybmZkZXbt2Tenn4vl14CPCywDx8fHUv39/zo+3QoUKtGPHDvYg//z5M8ugqq2tTUlJSZScnMyS0unq6tL3799LLaMqEdGWLVs412Bvby/TcS1atCAgN8tqRkYGW799+3ZOe9LqR79584Y2b97MKYyUd6lTpw7Nnj2bbt26Renp6XTr1i1at24d9ezZU6ZEhi1btqTZs2fTqVOnWAoRWREJ+dGjR+US8iNHjtDcuXOZiKmrq9P8+fPp5cuXcp1fGu/eveNkEwBykxeuXLmSfvz4UeT2eX5teNEoRYRCIf3zzz+cEqAAqEePHvT27VvOvuvWrWPbp06dytaPHDmSrRflKQoKCpIp99SRI0fI1dVVappxRbhy5QrnOrp37y7TcaJU2rVr1+as7927N6e9wvJXxcXF0fbt28ne3j7fjLyyLHp6erRw4UIKCAhQSv2HY8eOKSTkedPai5amTZvSypUr6dmzZ3KlCsnOzqZt27aRjo4Opz0HBwe5y/zy/L7waURKiZiYGIwfPx6BgYFsnZ6eHrZt28YyoorIysqCp6cngFxb/4wZM9i20aNH48CBAwByJ8T//PNP3L9/H8ePH4eTkxMiIyNhZGQEY2NjTpbbuLg4fP/+HRcvXkRMTIxSgubEPagA2SbCk5OTWdyJeCS4KBhQnMJiFQwNDeHs7Izq1avD2NgYfn5+zFU2PwQCAWf+Y+HChVizZo3SIpzfv3+PadOmsWv78uUL7OzsYGhoKLFvfHw8goKCEBkZicuXLyM8PFxqm6JsvMuWLYOZmRn69+8PZ2dnWFlZ5Tv/8ODBA0yYMAH3799n66pXr47NmzdjyJAh/LwFj8LwolHMZGdnY+vWrVi2bBnS09PZ+mHDhmHz5s1S8wcdP34ccXFxAIBevXqhQYMGbFu7du3QoEEDvHz5ElevXsXTp0+xZs0afPr0CRERETh//jy+fPmChw8fMrdafX19ODk5oVu3bvjy5QvCw8Mxfvx4tGvXrkjXpq+vj0qVKjFvJ1kmwvPLOXXnzh2kpKSw7wKBQMKTiIjw8uVLBAUFMffXly9fytVnccHo0KED2rVrh6ysrCKnDAdyhW/gwIFITExEYmIi6tatC11dXXh5ecHQ0BANGjRgQh4dHY2EhATo6urC2dkZWlpauHPnTqET+lFRUVi7di3Wrl2LOnXqMAFp06YNVFRUkJKSgmXLlmHbtm0cV+1x48Zh3bp1HHdnHh6FkGU4wqMYjx49Imtra45poHbt2nTp0qV8jxEKhczmD0DqJOXq1avZ9g4dOrDPeUu/5uXvv/9m+zZp0qTAes+yIt7XoUOHFrr/yZMn2f4rV65k65cuXcq5TxoaGpSVlUX379+nrVu3krOzM+nr6xdoZhIIBNSkSROaMmUKHTlyhGJjY+nbt280efLkAs1Xurq6NGTIEDp58mSRsrbOmTOHtVmzZk368OED5eTkUGRkJHl7e9O6detoyZIltGDBAho2bBgtWLCA44xw4cIFqlixYr5zLZaWlvleh4GBAXXr1k2iWp+lpSUFBwcrfE08PPycRgmQnp5Of/31F6fCm0AgoGnTpkmd3BUnKCiIHdO8eXOpNuzY2Fg2YSr6V01NrdBJ0+zsbGrevDlr39PTs0jXSUQ0YMAA1l6/fv0K3d/d3Z3tf/jwYbbexsZG4iEpXlpV2qKhoUFt27alhQsX0oULF1h1Q/HrnTt3LucYc3Nz6tu3b75tly9fnlxcXOjo0aOF/q3EOX78OGtDXV0935olZ8+e5Tz4PTw8ONsjIyPJzMws32sePHgweXh4UNeuXaVWEBS/fyNGjJDrGnh4pMGLRjFz8+ZNiR+9hYUFhYSEyHS8uFfVoUOH8t2va9eunHNMmTJFpvZDQkLYMRUrVqTExESZjsuP2bNns/Y6d+5c6P5Tp05l+1+6dInOnj3LqTFe0CKqYbFmzRq6efNmgRPlX758kbhH48ePZ95a6enpdObMGRo+fLiEY4Jo0dTUpD59+tChQ4ckBEmcyMhIzmTz9u3bC7wHu3bt4rxM+Pr6crZ//fqVevToke99qFmzJl24cIE+fPhAf/zxR741TYD/q2ty/PhxpUzy8/x+8KJRTHz79o0mTpzI+cGqq6vT8uXLZXZrfPXqFXsLrVGjBscdNS/btm3jvFUmJCTI3FdxD6zRo0fLfJw0Nm3axNpq0aJFgfv+999/1LRpU5kEQnQPBg4cSJ6envTw4UOZa09HRERwKsypqanRjh078vU8ysjIoEuXLtHYsWOZZ1feRV1dnbp3707//PMPffz4kR2bmprK8XoaMmSITB5Oixcv5ojTzZs3Oduzs7Np0aJFBd6fvO7DlSpVojZt2uRbK7xcuXLUt29fOnz4cIEiyMMjDi8axcC5c+eoZs2anB9o69at6enTp3K1M3PmTHb86tWrC9x38ODBnIfi169fZT5PQkICx3auSPlXEeJlW+vVq8fW5+Tk0LNnz2jnzp00ZMgQql27tkxCoampSQBIX19foUp0Fy5cIF1dXdZe1apV5Qpey8rKoqtXr9LkyZMlAi/FRdrBwYF27NhB/fr1Y+stLS1lfpsXCoU0YsQIjgBIC+g7evQoaWlpFXrfJk2axIQgPT2dzp49SyNGjMg3LkVdXZ26detGXl5ecsei8Pxe8KKhRBITEzkPbyDXJr5lyxaZ34pFfP36lZk4ypUrx3mbzcujR48kIpl37dol1/k8PDzYsVZWVnL3V4SPjw/ngb9+/Xrq1asXValSpdAHXYsWLWjmzJls8lZDQ4N9rlu3rlz9EAqFtG7dOs59ady4Mb169Uqh6yLKfdsPCgqimTNnUq1atQq8Fg0NDbkjqzMzM8nR0ZG1Ubt2balxNg8ePChUdPv06SP12MzMTPL396eJEyfm60igoqJCHTt2JE9PT3r37p2it4vnF4UXDSUgFArp0KFDEg9GR0dHev36tUJtik8Qjx8/vsB9nZycJH74rVu3lut8WVlZ1LhxY4VFJzk5mfz8/KhXr14yjSC0tLQ4UdyOjo5ElJsiRLTO3t6evRmbmJjI3Je0tDQaMmQI53z9+/enlJQUua6pIIRCId25c4fmzZtH9evXz/c6W7duTRs3bpRZrJKTkznOCU2bNqVv375x9nn9+jU5ODgUeo8rVqxI//zzT74jtOzsbLp58ybNnDmzQBGysbGhjRs3UkxMTJHvG8/PDy8aReT169cSE6xVqlShgwcPKmROIcp9gIvnBCoo79CNGzfYfjVr1qQmTZqw7+Hh4XKdV7ytKlWq0KdPn/LdNyEhgXx9fWnGjBlkZWVVaAR21apVqU+fPrRx40a6ffs2ZWZm0q1bt9h2UZS7uBvw2rVrmVdTw4YNZbqG2NhYCbfmFStWFDmvVkEkJiZS9erVC32IN2/enNasWUORkZEFthcfH8/5+3fu3JkyMjIoMzOT1q9fX6h5SkNDg/PdwcGh0Ae+UCike/fu0cKFCznzP3mXZs2a0apVq+T+v8Xz68CLhoJkZ2fT1q1bJSYZBw0aJNcktDTE3TULSsUhFAo5rqn79++nrVu3su9z586V+9x//vknO37ChAnsPC9evKB9+/bR6NGjC3yo5F0GDhxI4eHhUh/a4vMf7u7uRETUt29fti4sLIzNaTRt2rTQvt+6dYtjctHW1qaTJ0/KfQ/kITs7m7p06cLO2a5dO3r06BGtWLGCI+B5F0tLS1q+fDk9efJE6stFREQEZ+TarVs3zkgQABkZGdGJEydo9+7dEu62RkZGnO/ymEmFQiE9ffqUXF1dJc4pvpibm9Nff/1FYWFhCr8g8fx88KKhAM+ePZOIIzAyMqIzZ84opX1bW1vWrr+/f777nT59mu3XsGFDys7Opo8fP5K6ujoBuZPHmZmZcp07Li6Ovd0LBALq1KlTvhPAokUgEFDjxo1p8uTJNGjQIM62sWPH5nuulStXsv1OnjxJWVlZbNJaT0+PcnJy2AimME+svXv3susGcifhnzx5Ite1K4J4EKK+vr7EPEJ0dDStXbuWE/SYdzE1NaVFixbR/fv3OQ/f4OBgJprii4qKCk2fPp1jtgoODpZwFW7SpInE3EubNm3kHiVER0fTunXrqFWrVvleQ926dVlSyOIc1fGUPrxoyEFGRga5urpyHk4AaOLEiXJ5KxXEnTt3WLuNGjUq0B7dsGFDtu/p06fZNvEMprIIWVpaGl2/fp1Wr15NXbt2lfqgEl/U1dXJ1taWFixYQOfPn6cvX76wtpYtWybxkMqPUaNGsf0ePXrEMVcNHjyYcnJyCm0nKyuLpk+fzjmnvb19gY4DyuL8+fPsnKqqqnT9+vUC93/9+jW5u7tTmzZtCnz4zpkzh27dukXe3t4SEeG1atWie/fuSW3/7du31KBBA87+zZo1k3D91tDQoFWrVsn9QiE6x9atW6l9+/b5ppGvUaMGTZ48ma5evaqULAM8ZQteNGQkNDRUIuuoqakp3bhxQ6nnEfe++ueff/Ldb9++fWw/W1tbjriIP8z69u0rceznz5/p3LlzNH/+fGrTpo2ECOZdypUrR926daPVq1fTjRs3KC0tLd9+zZ8/n3Osjo5OvsInnvLk27dvtHz5cvZ937599OPHD/a9ffv2Esd/+vSJOnXqxDnf1KlTFXoYysurV6847qsbNmyQ6/h3796Rp6cndejQQa6MvAKBgPOCkJe0tDSys7PjHFO/fn26ePEimZiYkIqKCpmZmdGwYcNo8eLFtHr1atq0aRN5e3tTRESEXKOEhIQE2r17Nzk6OuYbjV61alUaPXo0XbhwgU+7/ovAi0YhpKSk0PTp0zlvVaqqqrRo0aJCU3XLy9u3b1k0b7Vq1fJtPz09nWN2yBsIlpWVRTVq1CAgN2bjwYMH9O+//9KkSZOoUaNGhT6YDAwMOA90PT09zmiiIKRFc//3339S9xV57FStWpWIiPMGHhsbSykpKey7g4MD59inT59yvJbU1dVpz549MvWxqKSnp5OVlRVHmIti009MTKTdu3eTg4NDvgIiPvmtqalZYEYBoVAo4T2mp6dHFy9epBUrVpCrqyvt3LmTAgMD6datWxQYGEheXl7k6upKmzdvVqi2yufPn+ngwYPUu3fvfEeqopxeJ06c4KPRf2J40SiAy5cvS1Q2s7KyoocPHxbL+ebNm8fOs2zZsnz3E3fHdXJy4mzLycmh8PBwCY+ughZTU1MaPXo07d+/n16+fMkegAMHDmT7yJqWZOzYsRLtX7hwQWK/jIwMJsQtWrSgpKQkJpgWFhZElJv6Q9RGt27d2LGnT5/m5IqqXr06BQUFydQ/ZTB+/Hh27gYNGijFNHnz5k2ysLCQ+W+mqalJe/bsKfDtfdasWWx/GxsbmWqs+Pj4kKura5ECPJOTk8nHx4cGDhyYbzS6lpYW9e/fn7y9vZVm2uUpGXjRkMKnT59o2LBhEiaaDRs2FJuNNiUlhdmvNTQ08vXA+vr1K/OqEQgEdP/+fQoNDaWNGzdS79698017IVpUVFTI2tqaZs6cSb6+vgV6esXGxrJqgSoqKjKJ5dChQyXOKc10Ix6P4eLiwsl2O2PGDCLKfQMXrevVqxcJhULO5DmQ68aa30imONi/fz/nwff48eMitffp0yeJMrmqqqo0Z84cevfuHXl7e1O/fv2oXLlyUv+eOjo6NHToUDp16pRUs+GKFSvI0tKy1Ko5pqWlFZrTS0NDg5ycnCRSsvCUTXjREENUZjNvOml7e3tO7eriwNPTk51v1KhR+e4nPmegr68vU0oJADRmzBjy9/eXO8vp2rVrWRtt27Yt9KGTt4woABo+fLjEfv7+/mz7ggULOJO158+fJ6Jcu79oXe/evTkZdIFc9+aipC6Xl0ePHnEe3gUlkCwMoVBIBw8eJD09Pc41tWrVSqo4p6Sk0LFjx6h///75mrC0tbVp4MCB5OPjwwIZc3JyaOXKlXKXmz169Cht3rxZqZ5QmZmZ5OfnR+PHj883rkVVVZU6depE27dvl7uuOk/JwIvG/yc2NpZ69uzJ+Q9csWJF8vLyKnYf9JycHI7Xi7iraGJiIp04cYJmzpxZoN+/aKlSpQr17t2bNmzYwElwN3HiRIX69uPHDzI1NZX5QSmejVX0cLOyspLYTzyz665du8jY2JiA3LkJ0QPv1atXbB/xt1SBQEBubm4lGhuQlJTE+liU+0mUmwXX3t6e83fT1dWlHTt2yBRH8fLlSwmxybuIkhHu2rWLXF1dKT4+Xq4+xsXFkaura76eWkUlOzubbty4QTNmzCgwJUubNm1o06ZNRUr/wqNcfnvRyMnJob///luibnK/fv1K7E3nzJkznB/J/v37acyYMZyHdX5L7dq16c8//6Rdu3bRs2fPOG+GycnJzLxUsWLFAr2eCuLy5cuc0U1BNmhxbyZREGC5cuUkHoYLFixg+x04cIB97tixI9snKipKqjnm3LlzCl2HouTk5HDqlbdo0UIhT6D09HRavny5RMT2wIED5f6/Fh4ezhFSExMTqabJYcOG0c6dO+XuKxHRzp07aezYsXTs2LFiFWhRSpYFCxZIuAyLL82bN6fVq1cXmCGBp/j5rUUjMjJSwj3RwMBAop5BcZGdnU0PHz4s8IcibVFTU6O///5bJlu+eObUf//9V+G+imdvnTlzZr77iQcmih+T17zn4uLCtq1YsYJ9XrNmDdsnb/W+Bg0alMoDY926dZyR3Js3b+RuIzAwUOIloG7dunTx4kWF+3Xjxg2OAC1evJgCAgI4yQgXLlxIgYGBCrUfGBjIxL1v375yj1YUQSgU0uPHj2n58uUFevpZWFjQkiVL6MGDB3w0egnzW4pGZmYmrVmzRsI1cPTo0TK7lipCeno63bhxg9asWUPdunXjpOyWtqirq1ObNm1o/vz51L59e7a+IM+qvFy/fp0dJ0tRpPx48+YNs+erqqrmm+ZdlGxPXV2dE+h36tQpzn6iCGmBQMBJHXLv3j3KyMiQCEirWbNmsf5t8iMwMJCZ2QQCQYGleaXx4cMHGj58uIToL1iwQCnzMceOHeO4g+/evZuI/i8ZoaurK926dUuhtm/dukVLlixhbVeqVIn27dtXog/pqKioQiPq69evT3PnzqWQkBA+Gr0E+O1E4969exKFf+rXr08BAQFKP1dSUhKdP3+eFixYQG3btpUwS+RdNDU1ydHRkVatWkXXr19nD5UHDx6wffT09CSynhaEUChk8QwCgUCht2QR4p5LHTp0kPrwELmN6ujocNKkr1q1irOfyJRSq1Yt5jVWtWpVev/+PUcgRcvkyZMV7reivHv3jjNhu3z5cpmPzcnJoX/++Uci87Gtra3S05ts2bKFta+iosIx323atKlIIw03NzeJSevOnTtLnWPIycmhiIgI8vb2pk2bNpGbm5vCgYPS+O+//2jLli1kZ2eXbzS6oaEhTZkyhQIDA/lo9GLitxGN79+/09y5czmeJyoqKjRnzhyleeDExsbSkSNHaPLkydS4ceN8/2OLlmrVqrF9dHR08p0r6NatGztmy5Ytcvdr1apVHFOQoqSnp3MC6o4cOSKxT926dQnIjZ0IDw9n+w4aNIjt8+3bN7a+WbNm7LOjoyMnLkY8yrik/w9mZmZyTG1du3aVucZIeHi4hNmzUqVKtHv37mJ7ExYvs1u+fHm6c+cOEeVWdJQ3zb2I3bt30+7du+nTp08SrtTly5cnDw8Pdk+ePXtGmzdvJldXV/Ly8lJq4KA03r9/Tzt37qQuXbrkW95WT0+PxowZQxcvXiyw6iWPfPwWonH16lWO5wuQm8zt7t27CrcpFArp+fPntHv3bho2bBh7WBa0NGjQgEaNGkX79u2j6Oho+uuvv9i2RYsWST3PtWvX2D516tRRaAL27du3TJzq1atXpAfXuXPnOG91eV14RckN69SpQ5mZmSxFSaNGjdg+jx49Ym2I144QH4nVqFGDkyZ9/vz5CvdZEcSrJtauXVum+IG0tDRavHixRFqWIUOGFDnzcWHk5ORwkkVWqVKF+vTpQ2ZmZuTq6ir3RLvIe8rMzIwaN25Mrq6u9Pfff0tUpLS1taXTp0+Tq6sr+fj4FHvgoDQ+f/5M+/fvp169ehUYjf7nn3/SyZMnS9RN+1fklxaNL1++SAROaWho0Jo1a+TOT5SZmUl37tyhTZs2UZ8+fWQKorOysqLp06fT8ePH6f3795z20tLSWBtqampSK6QJhUJOZtGDBw8qfC/EK8Ipaq4QIe6aPG/ePM42kanJzMyMiIil1lZTU2Nve+KBfNKK/7Rq1Yri4uLoypUrbN3ixYuL1Gd5EDeraWhoyPRy4efnJ/FiYmxsXGCWYmXz48cPCdOeiooKzZs3T+44jSNHjtDcuXMlRssNGjTgpFApzcBBaSQnJ9PRo0fJxcUl32j08uXLk7OzM/37779ymXp5cvkpREMRW+mJEyckUnq3a9eOIiIiZDpnSkoKXblyhZYvX06dOnVirqv5LeXKlaMOHTrQkiVLyM/Pr9D/jLt372bH/vnnn1L3EX+4NmrUSOESrERER44cYW0NGzZM4XaIcuMERG90ampqnHsqWt+sWTMi4iZgFD0oxNOg5F2GDRvGcm5dvHiRrXd1dS1Sn2Xl+fPnnBQlhbmrvn//nv744w/ONairq9OSJUsUdnFWlPv373Me6ECu08KmTZsUerCvXbtWogRA3utURJCKI3BQGmlpaXT69GkaNmyYRLZg8ZeCHj160N69ewssOsbzf5R50ZDXVhofH0/9+/fn/MeoUKEC7dixo8D/pImJiXTy5EmaNWsWtWjRIl87qWipXLky9erVi9avX08hISFy2UyFQiEnz9D9+/cl9snKyiJzc3O2z9mzZ+W/eWKkp6dTpUqVSEVFhRo3bkz79+8v0mSluDts586dSSgUclKZ29jYEBHR6tWr2bqjR48SEdHUqVOl3tNNmzZxHj7i8SvirrjFRUpKCufvMmzYsHwfhjk5ObRr1y6J1Bh2dnYl7hb89etXmjp1ar6R4j169KBbt27JZEI6cuQIubq6kr29PYtMj42NJQ8PD4l06CLTl6KBg4VVMFQmGRkZdPnyZRo3bpxExgdxgXVwcKAdO3aUiHvxz0qZFo3Q0FC5bKVbtmyR+BH36NGD3r59yzlGKBRSTEwMHTx4kMaOHUtmZmYFCgSQ6+UzZMgQ2rlzJz19+rRIb0mXLl3iPGSksXfvXraPLOk7ZGHWrFk0b948cnV1pd27dxdpsvL79++cSevjx4/T9+/f2Xd7e3si4haKWrJkCRGR1GI+0ibofX192XZ5U4/Li1Ao5IyKGjdunK/t+8mTJxI1MapUqUJ79+4tUZdPoVBI//77r8SI2tLSkvbv389x6R43bhw9ffo03xew3bt3k6urKy1evJiVANDT05P4vyCagO7cuTMNHz5c4cBBLy8v8vb2VsZtkJvs7Gy6fv06TZs2TaLCoWgRCATUtm1bcnd3p9evX5dKP8sqZVY0nj17ptCQWvw//L///ktCoZCys7Pp0aNH5OnpSYMGDSJDQ8NCRcLS0pImTJhA3t7eSk+IJz6/IK0caVpaGmfCURkZXEUCrMwsp6dOneKI6tu3b9l3UZnaly9fsnX9+vUjDw8PiXutpqYmNSeWuElNEa8xedi2bRs7l66uLkVHR0vsk5qaSvPnz5eoHTFixAj68OFDsfYvL1FRUeTg4MDpR/ny5WnDhg1svi4wMJAzKb9y5UrKycmhyMhI8vb2Jjc3N1qyZAktWLCAVq5cSZGRkfTt2zeO15i+vj5FRUVJ7cPGjRuL5M4rKvFbmuTk5NDt27dp/vz5EnNS4ouVlZVM9d1/B8qkaOTk5NDmzZvJx8dH7sm7efPm0ZAhQ+js2bPk5uZG3bt3z9eeKf7QsrGxoXnz5tGZM2eK1bb59OlTdt769etLnafYuHEj26dnz55FPqeiAlzYiEMoFHJSsIvX0ujfvz8R5f4tRUkV8wtmlFZgiYjo0KFDbJ/t27crdvEyEBISwhECaUJ+4cIFCQ85U1PTIjsVyEtaWhotXbpUIuanb9++Ul9uxIUXyC1uJSIoKIitF2UWJso1d7Vs2ZJtMzIyopiYGIm23dzcihQ46ObmptCxxYVQKKRHjx7RsmXLJAquiS8NGzakpUuX0sOHD3/LaPQyKRoRERFFspUW9AcHcuc4unTpQitXrqRr166VqAueuDeXh4eHxPakpCRWEU4gEBQ5EExRAZZ1sjIqKoq9zYq/1Q4ZMoTtU1iixdWrV0ttW9xEJ4p0VjaJiYkcE0Veb7C4uDiJ7LoaGhq0YsWKEq9Ed/HiRU6cDJDr2lzYfJf4S4iqqiqLao+OjmbrBw8ezDnm8+fPnCDYOnXqSIhSUQMHy8JIoyAiIyPJzc2NrK2t8/2/W79+fZo3bx6Fhob+NtHoZVI0vL29ycvLS6Fjd+7cKVELo3r16uTs7Exbtmyh+/fvl1qkaGJiIvMu0tXVlWqSEY/dKKqXE1HRBViW4fjChQslfkxjxowholyPHnHPM2llQUWBaHnZuXOn1DdkZZGdnc1JsNi+fXv2fyM7O5s8PT0lEll26tQpX3NNcREbGyuRcl5dXZ0WLVok0wuPUCjk1FHX1tam+/fvc4IsO3XqJHHchw8fOHXojY2NOabNovxOS3NOQxHevHlDmzdvpnbt2uUbtGtkZETTpk2ja9euFcnTsaxTJkWjqG8wf/31F40cOZL27t1LUVFRZWYIKZ6Yb86cORLb4+PjmSlHQ0NDKRNwJfHDTk1NlQj6mjJlCv37778SxYPyerZVrlw53x+Y+DzD4cOHFbqGghAXaAMDAxZL8+DBA455BsidIzt06FCJ/l/Kysoid3d3jgswkJvCRV4PrezsbI7w6OvrU0xMDPv7WFpaSj3u/fv3nESL5ubmLFBR9EKiaODgzzo/EB8fT3///Td17tw5Xy/LatWq0bhx4+jSpUsKR6MXd1oWRcmrB2ooA2RmZkJTU1OhYzU1NVGhQgXs379fyb0qGhkZGfj7778BACoqKpg2bZrEPqtWrUJ6ejoAYNKkSahbt26Rz5uQkAArKyuFjjU2Nsa1a9fQt29faGhoQENDA5qamuyz+GJnZ4cjR46wYy9cuIAdO3ZItPny5UvOdxsbG7x//16iPVVVVWRlZbH91NXVFbqG/Dh37hzc3NwAAKqqqjh27BgqVKiA2bNnw8PDA0KhkO07duxYrF+/HlWqVFFqHwoiJCQEkyZNwpMnT9i6atWqwd3dHUOHDoVAIJCrPVVVVXh7eyMxMRHBwcFITExE9+7dUa1aNcTGxiIxMVHqcQYGBrh69Srat2+P169fIzIyEl26dMG1a9dgamoKXV1dBAcHw8XFRaY+ERGCgoJQsWJFmJiYyHUNZYUaNWpg0qRJmDRpEj5//oyzZ8/i5MmT8Pf3R2ZmJgDg48eP8PLygpeXFypWrIhevXrB2dkZXbt2hZaWVqHnCA8Ph7+/P5KTk2FkZAQrKytoamoiIyMDMTEx8PHxga6uLhwdHWFpaVncl1wgZUI0NDQ0kJGRodCxGRkZCgtOcXLkyBH2w3R2dkadOnU421++fAkvLy8AQIUKFfDXX38p5bxFFWAiwpkzZ+Q+9s2bN1LXiz8EAeDSpUuoVauWxH4CgQAqKirs+6RJk7Bw4UIJcclPxAralpKSAnd3d9b2H3/8gQsXLqB///749OkTW1+vXj0sW7YMbdq0wbdv35Ceni7RrngflcHnz5+xcOFC/PPPP5x7MWHCBLi5uaFy5coKt12uXDmcOXMG7dq1Q0REBKKjo6Gtrc3Om52dDTU1yUdAzZo1ERgYiPbt2yM2NhZPnz6Fo6Mjrl69CkdHR/j6+iIgIACdO3cuUDiICAEBAYiMjMSAAQOUfu9Kg6pVq2LUqFEYNWoUkpOTceHCBZw8eRIXL15EWloaAODbt2/w9vaGt7c3ypcvDycnJzg7O8PJyQm6uroSbd6+fRt+fn6wsLDAoEGDYGhoyNlub2+P+Ph4BAcHw9fXFykpKbCxsSmR65VGmRANAwMDxMTEwN7eXu5jY2JioK+vXwy9UhwiwpYtW9j3WbNmSeyzZMkSZGdnAwDmzp2L6tWrK+XcRRVg8bd9RVFRUYGJiQlatWoFIyMjqKmpITs7G3Fxcbh79y5evHjBebMHcu9ZTk4O+56UlISkpKQi90Ua3t7eUte/fv0ao0aNKvBYVVVVpQiZuro6oqOjcf36dfawAYBatWph2LBhMDc3x5UrV+RuV7SIHuZVqlTBpUuX0KZNG7x//x7fv38HkHu/P336BAMDA6nXWbduXSYc79+/x4MHD9CtWzdcuXIFXbt2hZ+fH5KSktCuXTuJhxwAxMfHIygoCJGRkejatWupvx0XB7q6uvjjjz/wxx9/IC0tDX5+fjh58iTOnTuHb9++AQDS0tLg6+sLX19faGhowNHREc7OzujVqxeqVq2K8PBw+Pn5wdbWtkARNjQ0hIuLCwICAuDn5wcdHZ1Su6dlQjSsra3h4+OD+Ph4qf8B8yM+Ph5xcXEYPHhwMfZOfgIDA9kbduvWrdGmTRvO9gcPHsDHxwdArgli9uzZSjt3UQQ4KioK8fHxCp9bX18fY8eOhaamJoRCIfT19WFmZsaG2VFRUTA2NkZOTg7+++8/fPjwAZmZmcjIyEBmZibevn3LRmd6enpQVVVl2zIzM5nIliY5OTlIT09nZkVlExsby8xoRUFdXV1CRAQCAYiI7dO9e3dUqVKlQDHq1q0bfHx8kJaWhjt37qBp06aYPHkyKlasiJcvXyIiIgI1atSAiYkJ+zu/fPkS8fHx0NLSgo2NDfT09BAbGyshbGpqanKb3coq5cuXR79+/dCvXz9kZmYiMDAQJ06cwOnTp9loNjMzE+fPn8f58+ehqqoKe3t7dOzYEebm5oWO2oDcEWjnzp3x5csX+Pv7w8LColRGb2VCNH41W6n4KEOaICxatIh9XrJkCXR0dJR27qIIcGJiIvr27Qs7OztERUWx5dWrV5xRQH7Uq1cP6urqMDU1hZ2dXYHDbFVVVUyaNIkzzP7rr7+wdu1aAICPjw86derEOV4oFCIrK4uJiLigSFvOnTuHbdu2AYDEA7NChQro3r07zMzMOG3K0m5B2zMyMiRGUaVBVlYWsrKy2MhCGo8ePZK73devX2PevHkAuCPKV69eQV1dHVlZWYiPj8fdu3cRHR3NuefSkGXUpMhITpntqqqqynWPRGLbrVs37Ny5E8HBwThx4gROnjzJXspycnIQGxuL7OxstG/fXmbxFAgEsLOzg5eXF168eAEzMzO5+qYMyoRoqKioFMlWCgCRkZEICwtDQkICMjMzoaGhAQMDA1hbW8PU1LTEFDkqKgoXLlwAANSuXRv9+/fnbA8MDIS/vz+AXBPAhAkTlHr+ogpw3759Je5VZmYmYmJi8PTpU6xbtw4PHz6UaMPS0hLdunWTe5j98uVL2Nraok6dOoVOhKuoqEBTU1OmOZsHDx5g9+7dnGsUMXHiRKxduxaVKlUqtB1FyMnJkRCS8+fPY+XKlXj//j3br2bNmpg8eTIaN24skxgpsi3v9m/fviltxCYUCtmLhaKI+lWWUVFRUYoYubi44MuXL3jx4gUiIyPRqlUr6Ovro0aNGnL1x9DQEEZGRrh///7vKxpA7kMnJSVFblspAHh4eJQZrwMPDw/2edq0aZyJRiLCwoUL2fdVq1YpfRK/qAIsTVw1NDSgq6uLTZs2cQTD0dER/v7+UFFRQc+ePeUeZn/+/BkPHjzA8OHDoaGhwSZpATB7vpmZmdwP98+fP6N79+4SczuNGzfG7t27JcyFykZVVRVaWlrQ0tLC69evMW3aNPYiAeQ6HPz111+YP38+ypUrV6x9ycvRo0fxxx9/cPp67NgxtG3btlAxevr0KZYtW4YfP34AAJo2bYqRI0dKiKQyRU4Zc2xFRSgU4sePH+y6lYWRkZHCD31jY2OpL28lQZkRDSDXHVNHRwf+/v7w8vKCkZERjI2NOSIQFxcHXV1dDBgwACkpKfD19S0zXgdfvnzBwYMHAQDa2toYO3YsZ/vJkydx7949ALkPMPEfrzJRVIDzE9Xbt2+jf//+7C25fPnyOHjwIF68eAF/f3+YmJhAS0tL7mF2+/btERUVBVNTU0RFRXEe8qtWrcKqVasAANWrV4eZmRnMzMxgbm7OPterV0/C++fVq1do06YNPnz4wNaVK1cOK1euxMyZM5XuypsfmZmZ2LRpE1avXs2Z/+jatSu2b9+OBg0alEg/8pLXaSQnJwcjR47EzZs30axZswKP7datG2xsbNCtWzekpaXh8ePHCAkJwb///ivVC0sZEJHMJsmimhWLsk0W821e1NTUiuTpqKjDS1EpU6IB5D7wLCws8OLFC9y/fx8PHz5kbrX6+voYPHgwTExMEBERUea8Dvbs2cM8YUaPHs15Q87OzsbixYvZ97Vr18ptK5UHeQU4v3ty8OBBjB8/npkQ6tSpg9OnT6NZs2ZYvnw5AKBVq1YwNDRUaJhdo0YN9OrVC6qqqoiMjJQ6H/Dhwwd8+PABQUFBnPXq6uowNjaGubk5GjRogP/++w+nTp3imF/s7e2xb98+pcTAyMq1a9cwefJkREZGsnWGhobw8PCAs7NzqU7+iotGrVq1EBsbi5SUFHTv3h23b9+WcA3Pi52dHc6ePYsePXogIyMDx48fh6amJg4cOFAs/58FAgEz75QFRF6Ab9684SyvX7/G69ev8e7dO5nntLKzs3/KUIMyJxpArolF9DYpDaFQyLwHyorXQWZmJjw9Pdn5ZsyYwdl+4MABZvtt164dnJyclHp+acgqwNLuRXZ2NubPn8+Z1O/QoQOOHz+OatWqAQB7gzYyMlL4zdnExASpqakIDw/HiBEjcOjQIQDA/Pnz8fXrV2YzT0hIkDg2KysLkZGRnIezODVr1kTdunVx7Ngx9v/J2Ni42EYbiYmJmDt3LselV0VFBTNmzMCKFSuU6vCgKOKu3WZmZjAyMsLt27eRkJCAbt264datW4UGNTo4OODUqVPo06cPsrKy4O3tjXLlymH37t0/fSxGfqIgWmJjYxUaVQBA5cqVUbduXbbo6Ojg5cuXP12oQZkUjcKIjo5GcnIyBg8eXGa8Do4fP848I3r37g1jY2O2LT09Ha6uruz7+vXrS+xtszABlkZSUhIGDRqEK1eusHWTJk2Ch4cH54ErsvEqa5gt/mMcN24cR4i+ffvG8eiKiorC8+fP8x2dAMC7d+8kMgWoqamhfv367J6Im7z09PQU+rvk5ORg9+7d+Ouvv5h/PpA72tu5c2ehZp+SpEqVKlBVVUVOTg4+ffqEK1euwNbWlk3O9unTB1euXCl0rqV79+44fvw4BgwYgOzsbPzzzz8oV64ctm3bVqbdaEtSFMSXOnXqoGLFipz9IyMjf8pQg59SNMLCwmBkZFRmvA7yBvPldbP19PREXFwcgFxBsbW1Vdq5lU1ERAR69+7N0n+oqanB09MTEydOlNhXNNJQ1jC7IO+pihUrolWrVmjVqhWICD4+PggKCpIqGFWqVIGmpibHU0lEdnY2oqOjER0djXPnznG2Va5cWaqYiMx60ggLC8OkSZPYXJWonfXr12PMmDFl7s1bRUUF1atXx/v37/Hhwwfo6enh8uXLbB4oODgYQ4cOhY+PT6Hmpj59+uB///sf/vjjDwiFQmzfvh2amprYuHFjqQlHWRKFwvhZQw1+StEoan4lZXsdBAcHIywsDABgZWUFOzs7ti0pKYnFHggEAqxZs0ap51Ym58+fx5AhQ5CSkgIgN8DuxIkTaN++vdT9RSONuLg4pUT0y5J7KiYmBpMnT2ZuywBYxDmQ68YcFhaGKlWqICUlBdHR0WxkEhkZiaioKERHR0sNzktKSsLt27dx+/ZtznoVFRXUq1ePIyRGRkY4efIkDhw4wBGukSNHYsOGDcyEVxbR19dnoiEUClG/fn1cvHgRHTp0wPfv33HixAnMnj0bW7duLfRBNnDgQGRmZmL48OEgIri7u0NLS4s5MSibn0kUCqM4PB1Lgp9SNIqaX0nZrnN5U4aI/+E3bNiAr1+/AgCGDx+ORo0aKfXcyoCIsHbtWixZsoTFMzRt2hRnzpwpcGJU9OC9e/cujI2NizzMFvfXzysaIm+kVatWcf5+1tbWTLA1NDTg6+vLbPI6OjqwtraGtbU1py2hUIh3795xhES0xMbGSvRTKBQiJiYGMTExuHjxotRrqVixIlxcXNC1a1ckJCRAR0enxN1pZUU0r5GdnY2kpCRUrVoV1tbW8PX1Rc+ePZGTk4Nt27ahVq1amDt3bqHtDR06FD9+/MC4ceMAAKtXr4ampiaWLFkid99+JVGQBWV7OpYEP6VoFDW/UnJyMho3boxBgwZh4MCBMDU1Vbgvr169wunTpwHkZsMcOHAg2xYfH8/iNjQ0NLBixQqFz1NcpKWlYfTo0SytCQC4uLhg//79nLgJaYge3i9evECFChWKPMzOb6QRHByMCRMm4Pnz52xdzZo1MX/+fE7cy/bt2yUEQhoqKiqoXbs2ateujS5dunC2ff/+nTM6EV8Kiq7+9u0b/vnnH5Z4UCAQoG7duhxzl2ikUqNGjTLjQZWYmIiqVasCyHWp/eeff1j+rXnz5sHIyEgm1/CxY8ciIyMDU6dOBQAsXboU5cqVkxCd300UZEFZno4lxU8pGsrIr/Ts2TM8e/YMS5cuRbNmzTBw4EAMHDiQM4EtC9u2bWNv51OnTuW4Bq5cuZK9jU+ePLlQd8aS5u3bt+jbty/HXLdq1SosXrxYpoea6NqEQiE6duyI8+fPF2mYLS4aGhoa+PLlCxYsWMDJACvyRpozZw46derEXJxHjhwpERejCNra2mjevDmaN2/OuU43Nzds2LCBMxqqXr061NXVER8fL5Eug4iYG+bly5c52ypUqCBVTExMTFC+fPkiX0NhiIvGhw8f0LBhQ/Z95MiRiI2NxbJlywAAI0aMgIGBgUy/tSlTpuD79+9YsGABgFzRCQwMhL6+/m8tCrJQFE/HkuanFI2i5lcS93ABcnPwPHr0CH/99Resra2ZgBTm2//t2zfs3bsXAKClpcVJCRIdHc0edjo6OpwYjbJAcHAwnJ2dWRBchQoV4O3tjT59+sjchvi8QLNmzZCVlVWkYba4aBw7dgzz58/Hx48f2boWLVpg9+7daN68OQYOHIjo6GgAuaa0HTt2FMvb+6VLlzB16lS8evWKratTpw48PT3Rq1cvALn34cWLF5xRicjsJZofEic1NRVhYWHMrCZO7dq1pQYy1qxZU2nXl3ekkZclS5YgNjYWXl5eyMrKQt++fREcHIzGjRvLNFIQ59KlSzL361cWBVlQxNOxNPgpRaOoXgenTp1CbGwsfH194ePjw/F8Ef2YFyxYgFatWmHQoEFwcXGRWgNi7969SE1NBZA7XyEa5gO5PzzRG9W8efOgp6dX1MtWGl5eXpgyZQp7SNevXx9nz56Ve9grMk+pq6tDVVW10GF2VFQUEhMT8x1mi4uGeIpyHR0duLm5YdKkSVBVVcWWLVvg6+sLIHcuwdfXV+lv6O/evcPMmTNx4sQJtk5dXR1z587FkiVLOOfT0tJCkyZN0KRJE04bRISEhAQJIYmKisKbN2+ken69ffsWb9++5bg7A7lR+KamphJiYmpqigoVKsh1bQWJhkgUBg8ejLt37+Lx48dITk5GixYtoK+vj/j4eH6k8LsjS3m/ssizZ8/I1dWV/P39Cy3JKRQKyd/fn1xdXenZs2cS21+9ekXr1q0jKyurfAvK29rakoeHByt1mZWVRbVr12bbIyIiWHv37t3j1CtPSUlR7sUrSGZmJk2ZMoVzXQ4ODvTp0yeF2jM3N2f1z8XJycmhyMhI8vb2Jnd3d3J1daUFCxbQsGHDaMKECVLLVv748YNq1Kghcd8HDBhA7969Y/vdvHmTU3Lz9OnTCvU9P5RZcrUg0tPT6dmzZ+Tr60tr1qyh4cOHU+vWralSpUr5/h/MbzEyMiIHBweaPHkyeXh40OXLl+n169dS73NWVhYdPHiQHWtnZ0cjR46kjh07Ut26dfMtZyrLUrlyZWrevDn169ePZs6cyanHLhAI6OjRo0q7fzwlR5msEa4ooaGh5OrqSj4+PvnWLY6Li6MjR46Qq6srtWvXjh4/flxgm9HR0bRmzRpq2rSp1B+GQCAgOzs7Gj16NFvn5OTEaaNz585sm6enp9Kutyh8/PiR7O3tOdcyY8YMysrKUrjNunXrMmEs7NyVK1dm5w0KCuJsv3btGpmZmXH6VqdOHTp//jxnv/fv33OEZeHChQr3XRq3bt2iJk2aSNR+Lsla4UKhkBITE+nGjRu0Z88emjNnDvXs2ZNMTEzkfqCrq6uTvr4+1a1bl+rUqUN6enpFEgUAVKFCBerTpw/NmjWLPDw86MyZM/T48WP6+vWr1GuZOnUqO1ZVVZVOnTpVZmth80gnrx4IiCQT3s+ePRubN2/Ou7pMkre2rjSvAyA3Yjs8PBzm5ua4f/9+oZ5BQG7E5vHjx+Hj44Pw8PB895s+fTqWLFmCatWqISAggHnk1KtXD5GRkaWeN+fp06fo3bs3K8mqrq6OXbt2YfTo0UVq18DAAImJiahTp06+5V5F7Ny5E5MnTwYANGnSBGFhYfj69Svmzp3LkjyKEE2Ci/+NsrOz0aVLF1y/fh1Abk4pf39/pSTKK86Sq8okMzMTUVFRCA0NRVhYGJ4/f47//vsPiYmJSkkvXrFiRdSvX1/CdKSiooKRI0fi8+fPAHJjM44cOSLTpKxQKMTEiRNZaeMmTZrgjz/+QEZGRoFeQmWhFjZPLhJ6IIuylHXymkPc3NzI3d2dvL29KTIyktLS0qh58+bsjWf06NFyn+PZs2e0bNkyiTdiiL1FOTg4UJ06ddg6b2/vYrha+Th58iRpa2uzPunr69OtW7eU0nbFihUJAJmZmRW6b3Z2Nudv8Oeff1LVqlU591BTU5MAUNWqVSWOX7BgAdvP0NCQEhISitz/nJwc2rdvn0Q/rKys6M6dO0VuXxGysrLozZs3dP36dTpw4AC5uroqzXwky6KpqUmWlpbUv39/WrRoER08eJBu375NAQEBVL58ebbf7NmzZb6mnJwcGjZsGNnY2JCrqysdPXq0QMuAj48Pubq6UmhoqLJuK08R+KXMU/IQFRXFeXj+73//U6gdoVBIXbt2LfTHp6OjQ//88w99+fJFyVciGzk5OeTq6srpk7W1NcXGxirtHBoaGgSAmjVrJtP+ISEhUu9VxYoVaefOnWyOyMDAgHPcqVOn2L5qamoUHBxc5L4/ffqU2rVrJ/E327ZtG2VnZxe5/fwoTlEQn1MQmY9OnDhBZ86coSNHjtCGDRtozJgx1K5dOxIIBHK3L3pJEC1jx46l6OhomUycjx8/VtocJE/JklcPfkrvKUUwNTXFzp07MXz4cAC51dtatWold3bW2NhYBAQEAMj10z9z5gxOnz4NHx8fjokmJSUFY8eOxaRJk+Do6IhBgwahd+/eJeIhkpqaihEjRuDkyZNs3ZAhQ/DPP/9AS0tLKecQCoXMJCJL5HN6ejouXrwoUXZ18ODBcHd3R3JyMsLCwqCnpwd1dXW4u7vDwMAAhoaGGDlyJNt/06ZNaNu2rcL9Tk1NxYoVK7BlyxaOF9DgwYOxefNmufOZ5eVnCV6ztLTE8+fPoampiZ07d3ICGl++fCnV3JXXVV0UzCieoj5v/EnVqlUhFApx9erVn64WNo90fhvRAIBhw4YhICAAhw4dQkpKCgYPHoyQkBC55hy2b9/OfvSiGtc2NjaoV68eS+onnrk1KysLFy5cwIULF6ChoYHu3btj4MCB6NWrV7Gkyn79+jX69u2LJ0+eAMj9Aa5btw7z5s1TahyDeCqPwoQoICAAkyZNYkkQxRk0aBB8fHyQnJwMa2trmJmZcWzcN2/exPjx43Hx4kVYWlpi+vTpCvWXiHD69GnMmDGDE0tgYmKCHTt2SESG58fPIgqFoa+vj+fPnyMjIwMDBgzg/F/Mzs7GmzdvpEbFy5uiXk9PD+3atUOzZs3KVFZqniIgy3DkVyIlJYVMTEwUss2mpKSwIbqmpiazq3///p3j1RMSEkKhoaE0c+ZMMjIykjrUL1euHPXv35+OHj1KqampSrm2wMBAjn1eV1eXLly4oJS28/L582d2nu7du0vdJyEhgYYMGcK5bnV1dXJ0dCQAMtu4jx49Sq6urv+vvfMOi+L6+vh3FwVsYAsg2BEBsUUUS8CKmFiwBcEYNYlRYyWxawwSCzbAEhUVY4moYIuaoIEQRarRIBYUFLuCYhcEpeye9w/end+Oy8Lussvuwv08zzwPDDNzzyyzc+49laKjo1WS9c6dOzRo0CAZ2/3PP/9M79694x1b0eaj0qKPNImXlxcnV3p6usLnvX79ms6dO0cuLi7c+UKhkKpXry73vseOHUtBQUEqyRkcHKwTvsGqTJU1T0moXbs2wsLC0K1bNxQUFCAwMBB9+/bFoEGDyjx3165d3BJ9zJgxXJLUxo0buTLcw4YN43pQd+vWDQEBAUhISMDBgwdx6NAhbqb2/v17HD16FEePHkWNGjUwePBgeHp6YuDAgUqbkIgIQUFBmDlzJjfLbd26NY4fPw47OzulrqUo0tngH8orFouxY8cOzJ8/nyvWCBQ3n9q2bRtat26NIUOGoFu3bgp1Xhw1ahSioqIQHR2Nhg0bKhxVI6/las+ePTFp0iQUFRVh9erVerlSKC/SzZiysrIUNtOampqia9eu+Oeff+Du7o6//voLYrEYVlZWCAsL4/U9SUtLQ2pqqt72wmbIQRHNUhnZuHEjNxNq2LAhL4GsJIqKisja2po758qVK0RE9PLlSy4hSygU0rVr10q9RnR0NE2ZMoU++uijEmdltWrVotGjR9OxY8dkZsElkZ+fT5MmTeJd49NPP6VXr14p9Xkoy61bt7jxxowZw+2/evUq9ejRQ2aGvWPHDi7+XiQS0apVqyg0NFTh/AexWEyhoaEUGBhYahy/ZKWwbt06mWRBAwMDEgqFlWKlUF5WrFjB3deRI0dUukZOTg4vIbZFixa0dOlS+uabb6h79+7c92Lx4sUqR+zFx8eTn5+fSucy1EOVX2lImD59OqKionDixAk8f/4cX375JaKiouQ2nvnzzz9x+/ZtAICrqyvatWsHAFi1ahU3mx4/fjyv+NuHGBgYoFevXujVqxc2btyIs2fP4uDBgzhy5AgXA5+bm4sDBw7gwIEDqFOnDoYOHQpPT0/0799fphz806dPMXLkSMTFxXH75s6dq/H+4wB/pWFsbIy8vDwsW7YM/v7+vB7dY8eOhb+/P29me/PmTbx//x49e/ZUycYdHx8PsVhcok/hwYMHcjv5lbWC0KeVQnn5sGihIhQWFuLWrVtITU3F9evXkZqaioKCAi644e7du1yhQ2n0tRc2o2SqrNIQCATYuXMnOnbsiEePHiE6Ohp+fn746aefSjz+w54ZQHF9oo0bNwIodn5Lt3Qti2rVqqFfv37o168fNm3ahDNnzuDgwYM4evQoXr16BaA4AiskJAQhISEwNTXF8OHDMWrUKLi6uiIlJQVDhw7lnLpGRkbYsWMHvvzyS1U+DqWRVhpPnz5F27ZtcffuXW6fjY0Ntm7dir59+8qcW57Oi+bm5ggODsbevXuVlrkqKYWyKK3+VF5eHtdONzU1ldvS09N5E4KyaNy4Mdq0aYNq1aohPT1d73phM+SgyHKkMhMTE8OZLIRCIcXExMgcc/HiRW4Jbmtry5lHJk6cqJJDvTTy8/Pp5MmTNH78eJm4eMlWu3ZtnkPW0tKywpPRYmJiSpTN0NCQlixZUqppzd/fn06fPq3SuKdPn+Yl+snbjIyMyNPTk37//Xe9NB9pmn///Zf7rHr37k2zZ8+mgQMHUvPmzZXK4RAKhWRjY0POzs5UrVo1br/0OyQ1NZV8fX3lBjvIIyMjg3x9fSktLU3dt89QAmae+gAXFxf4+vrCx8cHYrEYX3zxBS5dusSrWCu9yvj+++8hFApx48YN7Ny5EwBgYmKCRYsWqUUeSVjuZ599hvz8fERGRuLgwYM4fvw4V2ZbUlkX+N+K5e3btxCJRBo3SwHFZp6DBw/K7O/duze2bt1aptOzvJ0XjY2N8cMPP8Dc3ByxsbE4deqU3rVcrSiICFlZWbxVw/Xr15GSksIdEx0dzZVnkYehoSFsbW1hb28Pe3t7tGnTBvb29rCxseHydI4fP44RI0ZALBZj3bp1sLa2xrRp0/S2FzZDDopolspOUVER9e7dm5slubu7cw7ajIwMbgZVv359ys3NJSKikSNHcscvW7ZM4zI+efKEOnfuXOqsz9zcnKZOnUpnz57VWFZzcnIyOTk58catWbMm7dmzR2GndnlXGgEBAbR//36ysLDgyeHg4FDiSrEqIBKJ6O7duxQeHk7+/v40YcIEnjNa0a127drUpUsXGjduHK1atYqOHz+ucNY3EdGWLVu4awkEAjp69CgRqbcqNaNiqbJlRMoiIyODGjZsyD3wGzduJCKiRYsWcfsWLVpERETnz5/nvajVlWchj/T0dLK3t+d9GcePH08eHh5Uo0aNEr/8jRo1opkzZ1JcXJxaqobm5OTQ7NmzS8xTUFZphoSEUHBwMBGR0hVPt2/fTt9//72M0lqzZg0VFBSU+z51nYKCArp+/TodOXKEli9fTl988QV9/PHHvLpQimzSFW8/+ugjioiIoAcPHqilmu/ChQu5cYyNjbnIKUWrUkvycljtKd2AmafkYGlpid27d2Pw4MEAgDlz5sDR0RFbt24FUFwZdtq0aSAiXl9qHx8fhSrmqsrff/8NT09Pzjler149hIWFcRnMb9++RXh4OMLCwnDy5EkuSuXx48fYuHEjNm7ciMaNG8PDwwOenp5wcnJSOjP8jz/+wPTp0/HgwQNuX6NGjbjcFGlTniJIOi/Gxsbiv//+4yoUd+rUiZcNHhYWxqt4mpmZiczMTF43uGHDhmHDhg1o2rSpUjLoOhJntLRJSVVntLQ5SbJ99NFHsLGxwa1bt5Cfnw83Nze1yb5ixQo8evQIe/fuxfv37zFkyBAkJCToXS9shhwU0SxViVmzZnGzJDMzM+7nL7/8koiIIiMjuX0tW7ak/Px8jcghFospMDCQl1dgb29favZudnY2hYSEkLu7O1dM8MOtWbNmNGfOHLpw4UKZs8qHDx/S8OHDZRzMy5Yt4+W57Nq1S6l7E4lEtHLlSqUqniYkJNCBAwdozpw5JBAIyNzcnP744w+lxtVFXr16RQkJCfTrr79yzugWLVoo7Yxu1aoVubu70/z582n37t3077//0ps3b0od+5NPPuGuoUhOkDLk5+fz+so0b96cHj9+TERlV6Vm/TR0C2aeKoP8/HxydHSU+WImJSWRSCTiJTPt379fIzK8f/+evvrqK974Q4YMKfMlIM2rV69oz549NHDgQF5Ui/TWsmVLWrBgASUnJ/MUSFFREa1fv16me52rqyuntNatW8ftP3DggFL3p6p929fXlxwcHLhxPTw86MGDB0qNrQ3EYjE9fvyYTp8+TZs2baJp06ZR3759S+xUWNpmaGhIbdu2pVGjRtGSJUsoNDSUrly5ovILf8SIEdy179+/r+a7Jnrz5g117NiRG+Pjjz+m7OxstY/D0CxMaShAeno6z1cg6RcRGhrK7evYsaNGZkSZmZnUrVs33sti0aJF5RrrxYsX9Ouvv9KAAQPk1k6ysbGhxYsXU2hoqEzbWzMzM9q3bx/vBe/n58f9XZmWqyKRiAIDAyksLEypbPADBw7QTz/9JNNRsWbNmrRq1SqNrfiUQeKMPnnyJOeM7tGjR7mc0StXrlTaGa0oU6ZM4cY8f/68Wq8tISMjg9cW2c3NrUr4nioTTGkoSLt27XgmmZSUFGrVqhW379SpU2of8/z582RpacmNUaNGDbX3VX727Blt376d+vXrp1BJjUmTJpXYE8THx4c75q+//lJ4fEnMfmZmplJyS2L2r1+/Trt27ZIpw2Jra0t///23UtdUlYKCAkpNTeWc0WPGjKFOnTop7Yxu0KABubi40KRJk2j9+vVqdUYrgnS/FU2a+q5fv85r9ztu3LgKu0dG+WFKQwGuXr0q8wVv3Lgx93Pv3r3V/tDv3buX61wHgJo0aUJJSUlqHeNDsrKyaMuWLTyTz4db27ZtaenSpXTjxg3euXPnzuWOOXv2rMJjSkdOKYt0xdOXL1/S9OnTZRSfOk1WeXl5lJycTPv27aPFixfTyJEjyd7evtSKriVtjRs3pv79+9PMmTNp69atdPbsWXr69KlaZCwP0uGxO3bs0OhYsbGxvOf7xx9/1Oh4DPXBoqcUQDqZz8zMDE+fPsWjR4+4fatWrVJbbwqRSIQFCxbA39+f2+fs7IzDhw9rvHzCu3fvcOrUKV7/c6FQyEuUS0lJQUpKCnx8fNChQwd4enpi1KhRpVa5LY0nT56gU6dOKskrXfG0Xr16+OWXX/DNN99g2rRpSExMBFDcCz48PBw+Pj744YcfFOqV8vr1a165DEm00r1793gNo0pDKBSiZcuWMpFKdnZ2MDExUel+NY0q9adUxdnZGfv27YOHhweICCtWrECTJk0wefJkjY7L0ACKaJaqRFZWFjcjMjU1pcTERJ4foFu3bmob69WrV/Tpp5/yZqUTJ07UuH2+sLCQ/P39Zcwpn332Gd25c4cePXpE69ato+7du8udPUvntEgq/iqCn5+f2iueikSiMk1WYrGYnjx5QqdPn6bNmzfT9OnTy+WM9vDw4JzRly9fVnv0UUUQFxfH3Ze3t3eFjLlhwwZuTKFQSMePH6+QcRmqw8xTZSBt550zZw69ePGC5xQ3NTVVi/kjLS2NWrduzV3XwMCANm3apHFb77lz52ScyRYWFnTw4MESx75//z75+/vLZIFLb+3bt6eAgACFPpfyZoOvWLFC7t9fvnxJ06ZNkzFZNWjQQG4dL3lb7dq1qXPnzpwz+tixYxpxRmuT9PR07n69vLwqbNw5c+Zw49aoUYMl8ek4TGmUwrt377jcDAMDA7p//z7vAZdsLi4u5Xp5hIeHk4mJCe+ldubMGfXdSAm8fv2apk6dyov/FwgENG3aNIWL+d25c4dWr14tE10lvfXo0YPWr18vN/eiPD6NoKAgmjRpEr17945zRh89epRWrFihFmf0unXr6K+//qpQZ7Q2efPmDfc59OnTp8LGFYlEvM6BDRs2pJs3b1bY+AzlYEqjFHbu3Mk9yKNGjaKHDx9ypiojIyNeZJOPj4/S1xeLxbR69Wrei7tdu3Z0584dDdzN/8YMCwuTqdPUoUOHclXG7dWrV6kvY4FAQC4uLrRp0yYuqYuo/BVPbW1tyczMTGlntGSrV68ezZw5U2ec0dpELBaTsbExAcV1uyqS9+/fU58+fbj/S8uWLbn2yQzdgikNOYjFYl6YbWJiIk2YMIFnqoqPj+f8GwKBQCkzS15enky/7OHDh1NOTo7G7unOnTsyPpOaNWtSQEBAuc0sffv25a558eJFWrp0qdwoLIFAQL1796agoCB6/PixynkakmxweQpBkhk9ZMgQmjdvHu3evZv+/vtvmjRpkkajrPSZZs2acbP9iubVq1fUtm1b7n/SuXNnjX4fGKrBlIYcoqKiuIe3e/fudP36de5FY2pqSi9evCAiflKbpaWlQrPVhw8fylSo9fX11Vi5hIKCAlq5cqVMMcMhQ4aoLfNX2kkuXVE3JSWFfHx8yNbWVu6LffDgwSplhEsrpfr16yvljL548aKMY1+XEgO1hcRXJRAItOKvefjwIS+cfeDAgZXKb1QZYEpDDgMHDuQe3IMHD/JKLEg7X0UiEa+mzsCBA0t98cXHx5O5uTl3fK1atVTuyawIcXFxMjN+KysrOnr0qFrt9B9//DEBoOrVq8v8TZIZvWXLFnJ1deX5byRbt27dFKo9deDAAfL19ZXJkjcwMJDJHSkLRaKsqhqDBw/mPgdlEy7VxdWrV3mBChMmTKgSPiV9gSmNEkhNTeUe2GbNmvFCES0sLGRKnz9+/JhXzDAwMLDE6/7666+8woHNmzdXKjxVGV68eMHrJCiZ1Xt7e2uk3o+dnR0BxVFGEmf0l19+qZQz2sHBgebOnUu+vr4UFBREp0+fpvj4eDp9+jRt376dfH19KTAwkFJSUujEiRMyJqZPP/1UJdkrIjFQX5A2wSYnJ2tNjujoaN53xdfXV2uyMPgwpVEC3333Hfewrl27lteQKSgoqMRz/vrrL+6Y6tWr04ULF7i/FRYWkre3N++F1Lt3b3r27JnaZReLxRQSEiIze3Z0dKT//vtPLWPk5eXRpUuXaP/+/fTTTz/R559/rpIj2srKilxdXcnT05NcXV3J3NychEIh2dra0tixY2n+/Pm0ePFiWrBgAc2ePZu2bdvGi+w6cOCAzDWVLZYoDTNZ8fvFREREaFUW6dpugOaz1BmKwZTGBzx//pyz/deuXZuOHDnCPbStWrUqtbjavHnzuGOtra3pzZs39Pz5c+rXrx/v4Z8+fbpGirTdvHmTZyqT3MOGDRtU6tz3+vVrSkxMpJ07d9LcuXNp0KBB1LJlS6XLdFtbW3PO6F27dskt0y0WiykxMZF++OEHsrKyKvF6xsbGNGLECAoNDaW3b9/St99+y/t79erVyzVDruomK+lku99++03b4lBAQADPBBkeHq5tkao8TGl8gLRje8aMGbxSzmUVCywoKKCuXbtyx0t6IUi/0LZv3652md+/f09Lly7l1fIBQCNGjKCHDx+Weq4kM/rMmTO0ZcsWmj59OvXr148XTqzMVqdOHfLx8Sl3ZrRIJKLY2FiaMWOGTHiwZKtRowYNHz5cJlGvZs2aStW/KomqarKSXr2tXbtW2+IQEfE6M9asWZO3imdUPExpSJGfn8+9LAUCAa9HRKdOnRSKbrpz506Jjt6PPvqIYmNj1S5zdHQ050+QbE2bNqUTJ07wjhOJRHTv3j06deoUBQYG0rfffkuffPIJ1a9fXymlUKtWLercuTONHTuW/Pz86NixY3Tjxg3O/tyxY0e132NRURFFR0fT1KlTeb6j0jYjIyP6/fffyz12VTNZnT59mrvPOXPmaFscIip+dj08PDi5zMzM6Pbt29oWq8rClIYUISEh3IM5dOhQatmypdL2XbFYTJ6enryXjL29vdqb2jx79oy+/vpr3jgGBgY0a9YsSkpKot9//51zRjs6OlKtWrWUUg7169cnZ2dnmjhxIpcZff/+/RIVZ1FREXde9+7d1XqfH1JYWEj//PMPTZo0iRo0aFCmaWzLli3lHrM0k1VkZKQa7kp3uHbtGnd/48aN07Y4HO/evaOePXtystnY2FT5ZExtwZTG/yMWi3nlMH744Qfu5759+1JRURGlpqZSSEgI+fv7k5+fH/n7+1NISAilpqaSSCSit2/f8mZEkq1t27aUl5enNjl3794t88KsX78+WVtbK+2QljijZ8yYQUFBQRQdHU1ZWVlKhTjm5uZy16vI8hMFBQUUERFBEyZMKHF1J71KDA8PL/fKQJ7J6vPPP680Jqvnz59z9zVgwABti8Pj5cuX1KZNG06+rl27Um5urrbFqnJ8qA8ERLK1n2fNmoXAwMAPd1cqYmJi0KtXLwBAx44d8fjxY2RlZQEAjh07hjt37iA7OxtWVlawtraGkZER8vPzcfv2bWRkZKBWrVo4c+YMTp48yV1TUkYdAKZOnYrNmzcrLVd2djZXmjsuLg7Hjx/HixcvlLqGQCCQW6bb1NRUaZk+5MWLF2jYsCEAYODAgQgPDy/3NZWloKAAX3zxBY4cOSL3mLp162LkyJHw9PREnz59UK2aap0ALl26hKlTp3Ll1wGgZs2aSpVf11XEYjEMDQ0hEonQsWNHrvS8rvDgwQN0794dmZmZAIAhQ4bg6NGjKv8vGcojow8U0SyVkWHDhvGcnZKfJ02aRL6+vhQWFlZq0lloaCiXdFanTh06ceIEpaSk8LKw5SXxicViysrKoujoaNqyZQvNmDGDXF1dlXZGV69enRwcHMjDw4N8fHzowIEDFVKm+9GjR5wMI0aM0OhYpZGdna2wz6Nhw4Y0efJk+ueff1SKLKvMJitJefhGjRppW5QSuXTpEtWpU4f7zCdPnsyS/yoQZp4iolu3bnFhpBYWFpypo127diqVt5Bud7p9+3bu4a5bty7Fx8dzzuiJEyeq5IwWCARkY2PDOaN///13unHjhtbKLUiX1B4zZoxWZJCwb98+GdNgWW1szczMaOrUqRQdHa20AqmMJitJxGC1atU0VtqmvERFRfFMscuXL9e2SFUGpjSIaObMmdzD5+zszDlRlyxZonQhvdDQUAoMDKTU1FTOGS0pAqfsJp0RCxQ7uqdNm6ZzRdyk2+FOmDBBq7KIxWL65JNPeJ/bsmXLuOqtQHFlW+nfpbdGjRrRjBkzKC4uTqkXZnJycqWJshowYAB3D8+fP9e2OHKRDlwBQLt379a2SFWCKq80Xr9+TbVr1yagOExTkusgWWUoW39HumS3ospB2hm9efNmmjNnDtWtW5d3zCeffEJXr17V0KdQPs6fP8/JOX36dG2LQ1euXOElIDo4OFBMTAzvM23VqhVt3LiRRowYIVeBNG7cmH744QdKTExUaOJQWUxW48aN42S/du2atsUplVWrVnGyVqtWTetZ7FWBKq80/P39uYdOOt/Bx8enXM2Bxo4dW6qimDNnDp07d45XFiMlJUVmlly3bl3avn27zpoJiIhiYmJ496ULSK8eJbPQq1ev8vxEjRo1osuXL1N2djbt27eP3N3dZVZ3kq1p06Y0Z84cunDhQpkKRN9NVtKNxlTtqlhRiMVimjZtGidv7dq1KSkpSdtiVWqqtNIoLCykpk2bcg+c5Etet25dWrt2bbnakPr4+HDO6EuXLlFeXh6tWbOGG8vc3JxrMpObm0sLFy6katWq8V4yY8aM0YtGNBEREZzMP/30k7bFIaLiFaT0yqJhw4aUm5tL9+7d460CTU1NKSYmhnfenj17aNCgQXLDl1u2bEkLFiygixcvlqpA9NVktXbtWk7esqog6AJFRUU0fPhwTmYLCwu6e/eutsWqtFRppREWFsZ7iUt+XrlyJfn5+VF8fLxK142Pjyc/Pz+Z/SKRiGcvdnNzo/DwcF6pEYnpRJ/qHB07doyTvbSe3RXN7t27eZ+rpFLqs2fPeD3OjY2N6fjx4zLnv3z5knbu3EkDBgzgmm19uNnY2NCPP/5IV65cKVGB6KPJ6rfffuPk3LBhg7bFUYi8vDzq0aMH7/PVZX+MPlOllcaHPRkkJovc3Fzy9/cv10ojICCgxL9lZWXJraVUvXp1+umnnzQeIqtupKuRyisLrw1EIhGvdpihoSHXajYnJ4enwIVCYalVVJ89e0bbt28nV1dXudFYdnZ2tGTJkhL9APpkspJeOS5atEjb4ijM8+fPeavIHj16qC2plvE/qqzSSExM5B4u6RIbW7duJaLiyAxVfRrBwcEUEhJS4t9EIpGMvR0A9ezZk65fv67y/WiTXbt2cfchr3S8trh48aKMyU9Cfn6+TMtdPz+/Mn0WWVlZFBQURL1795Zb8bdt27a0dOlSSktL452rDyar5ORkTjZtR8Mpy927d3mTsuHDh6uUh8OQT5VVGqNGjSrR1CApWZ6amkq+vr5yE/rkIYme+vBlQUR0+fLlElc3DRo0oJcvX6rlvrRBUFAQdy+7du3StjgyfPXVV5x8AoGAF4UmEol4VVQBkLe3t8KBB48fP6ZffvmFXFxc5CqQDh060IoVK+jWrVvcmLpsssrMzORkGjJkiLbFUZqLFy9yEZFAcUQfS/5TH1VSady/f5+zUUs7nw8ePMgdIxKJKDAwUKU8jXXr1vFeOm/fvqW5c+fK2MWlXxoeHh56+2AHBgbqtOP0xYsXvO6BTk5OvL+LxWJe6CYAGj16tNIz/0ePHtH69etlVhLSm6OjI61evZru3r2rkslKJBKVWQOtvBQWFnIK8MPPSl+IiIjgfbdXr16tbZEqDR/qAyGqAL/88gtEIhEAoKioCADg6OiIkSNHcscIhUK4ubkhNTUVUVFRINmSXDyICFFRUUhLS0P//v0hFBZ/lH/++SccHBywdu1abkxbW1ucOXMGFy5cQN26dQEAhw4dQnBwsLpvtUJ4//4997OxsbEWJSmZ+vXrY+3atdzv58+fx6lTp7jfBQIB5s+fj19//ZX7vx04cABDhgzB27dvFR7HysoK3t7eSEhIwP379+Hv7w8nJyfeMUlJSZg/fz5atGiBTz/9FM2bN0d4eDi6d+/OHXP48GHY2dlh9erVKCgo4PZfu3YNGzZsQFhYGN69e4dOnTqhV69e6NSpE969e4ewsDBs2LAB165dU/ozkqZatWpo0KABAHD11/QNNzc37Nixg/t9/vz52L9/vxYlqsQooln0mezsbJmmPQDkRislJiYqVXsqMTGRiIpnnSNHjuSNYWRkREuXLqX3799z50p3BjQ2NtbZBL7S+Omnn7h70NXkKpFIxItSa9SoUYm27uPHj/OS/bp06VLuEtx37tyh1atXk6Ojo9wVSLdu3Wj06NEy1YslJitFn8OwsDDec6gqkmqyxsbGersCJiJavnw5L9AkKipK2yLpPVXOPCXdzlKyubq6lnpOSkoKBQYGkq+vLwUHB9Pp06cpPj6eTp8+TcHBweTr60uBgYGUkpJCRUVFtHHjRl5BNQDUr18/unnzZonXnzp1KndcmzZt9K7c89y5czn5y9sxT5OcO3eO9z+RF+EWGxvLy/Fo3bo13bt3Ty0ypKen04oVK6hDhw5yFUijRo1kMtpVqYGWkpKispx9+vThxi+pNa++IBaLafLkydy9mJiY0OXLl7Utll5TpZRGUVERr7GSZFOkfaRIJKK0tDQKCQmhgIAA8vPzo4CAAAoJCaG0tDQSiUSUlJREnTt3lvFbhISElPplf/fuHbVv3547Z+LEieq8bY0zffp0Tvbz589rW5xSGTx4MCdrjRo15NbxunLlCi973NLSkq5cuaJWWdLS0mjp0qXUtm1buQpEKBTS3LlzKTQ0VKUaaKr6OLy8vDgZ0tPTVbqGrlBYWEhDhgzh/S/V3RStKlGllMbvv/8u86X08PAo93Wzs7Pp+++/l3FoTpw4kV68eKHQNVJTU3nOWl10KMvj22+/5eRW94tV3Tx79ozL9BYKhTR16lS5TuU7d+5Q69atuXurW7euRlr2EhWvZpcsWSLTutfW1rZcNdBKiuJTBG9vb06GuLg4la6hS+Tm5lLXrl25e7K3t9friEVtUqUc4evWreP9bmBggOXLl5frmseOHUObNm2wfv16iMViAICDgwNiY2Oxfft21K9fX6Hr2NnZ8Zo0TZo0CXfu3CmXbBXFu3fvuJ9r1KihRUnKpmHDhli0aBEcHBwwe/ZsmJmZyXUqHzt2DLt370aXLl0AAK9fv0b//v1x4sQJtcvl4OAAX19fXL9+HVeuXMGPP/6IVq1awcnJCebm5mjUqJFS17O0tISVlRX+++8/leQxMzPjftZXZ7g0NWvWxB9//IFWrVoBAFJTUzF06FBeEAdDRRTRLPpIUlKSzCpj0qRJKl/v/v375O7uzruesbEx+fn5qZykJRaLacyYMbzQUF1J+CoNaYf/w4cPtS1OmcTHx5Ovry+FhoYq5FSOjo4mNzc37h4NDAzo119/1bicklBgTVQmKIsdO3Zw96uOPuu6wq1bt3iNujw8PHS6GKguUmVWGh+uMoyNjbFkyRKlr1NUVITAwEC0adOGN+McMGAArl27hoULF6rc7lMgECAoKIibDZ0/fx6LFy9W6VoViT6tNK5du4a///4bPXr0wKhRo2BpaVnicZaWlvDw8ECPHj0QHR2NNWvWYPTo0QAAkUiECRMmYNWqVWWGYpcHgUAAsVgMIyMjlc43MjJCXl4e0tLSuFWwopibm3M/S1oWVwasra3x559/ombNmgCKQ91nz56tZan0m0qpNDIyMhAaGsrb5+3tLfeFIY/z58+jS5cumD17NnJzcwEAFhYWCA0NxalTp9CyZctyy1qnTh2EhoaievXqAIC1a9fir7/+Kvd1NYm00tDFPA0JYrEYkZGRsLe3h6urKwQCQanHCwQCuLq6ws7ODqdPn8Zvv/0Gb29v7u8LFy7ErFmzlH4hK4OhoSHy8/NVOjc/Px9v376Fvb096tevj/79++PHH3/E8ePH8fjx41LPlVYalcE8JU2XLl1w6NAhGBgYAADWr1/P73nNUIpKqTQ2b97MJfEBQN26dTF//nyFz3/z5g2mT5+Obt264dKlSwCKXyhTpkxBamoqPD09y3wBKYOjoyPWrFnD/T5u3Lgyv+TaRNourMsrjZs3byI7OxsuLi4K/78EAgFcXFyQnZ2N27dvY926dVi5ciX39/Xr12Ps2LG8JDx1YmFhgdu3b6t07o0bN5CZmQmg+BmOioqCn58fhg0bBktLSzRp0gQjR47E6tWrcebMGeTk5HDnVmalAQADBw7Etm3buN9nz56NsLAwLUqkv1Q6pZGXl8d7OIDiGWK9evXKPJeIcOjQIdjb22Pz5s2cKaJ9+/ZISEjAli1buIxudePt7Y3BgwcDAJ49e4Yvv/ySyyjXNSQrDUNDQy6jWhdJSkqClZVVuZzKAoEACxYswI4dO7h73b9/P9zd3ZXKHlcUR0dHZGRkcC9/RcnMzERWVhZsbW0xbNiwEu/50aNHOHr0KBYsWIC+ffvC1NQUbdu2xTfffIPjx49zx1VGpQEAEyZM4Jmox40bh+joaO0JpK8o4vjQJ6SL6eH/Y7QVSZ67e/cuDRw4kHduzZo1ae3atVxRQ03z7NkzXq6ALvWqkEYSJmpiYqJtUUpF3eXuP8wed3JyomfPnqlDVA511UATi8X08OFDOnLkCM2fP5/69OnDK+pX2mZsbEze3t60b98+unXrll5niH+IWCymCRMmcPdqamqql1UZKpJKnachEol4cfYAaPv27aWeU1BQQKtXr6YaNWrwzhs0aJDasoKVITo6msv/MDAw0MmY+WbNmhFQ3MhKl9FEY62YmBheWRpbW1u1PycpKSkayQgvKiqia9eu0a5du2jKlCnUqVMnme6RJW3169enTz/9lHx8fOjPP/8sd5kVbVNQUECfffYZd3+NGzfWiyhAbVGplUZ4eDjvYW/dujUVFhbKPT4hIYHatWsnszI5fPiwVmdXS5Ys4eRp2rSpwgmDFYWk62GzZs20LUqpaKqx1pUrV6hRo0bc/8jKykrts1VVa6ApS15eHiUkJND69etlSreXtjVv3pxGjRpF/v7+FBsbq3elcHJycni1wdq1a0evX7/Wtlg6SaVWGv369eM92IcOHSrxuJcvX/Lq0+D/s4VnzpypE3V3CgsLqWfPnpxsw4cP1ykTgYmJCQHFnet0GU011iIqNmd+mD2u7lWhMjXQ1MGIESO4+9mzZw8tXbqUBg8erJAyMTAwoA4dOtDEiRMpODiYLl++XOqETRd48uQJr8xQnz59eMVFGcVUWqVx5coV3kPcpUsXmRetWCym/fv385J9AFCnTp0UqkdVkTx8+JDq16/Pybh582Zti8RhaGhIAKhjx47aFqVUNNFYS5qnT5/yao8ZGxvTiRMnyiOyDIrUQFMXU6ZM4e5FuqaYWCymu3fvUlhYGM2ePZtcXFx4JXDkbTVr1iQXFxeaM2cOHTx4kO7du6dTkx8iops3b1LDhg05mUePHs2S/z6g0iqNcePG8R7Yf/75h/f3W7duUf/+/XnH1K5dm9avX6+zM6ITJ05wshoZGdGlS5e0LRIVFRVxMnXv3l3b4pSKOhtrySM7O5v3XBkYGNDOnTvLK7pW8PX15e7jjz/+KPXYwsJCunz5MgUHB9PEiROpQ4cOcnupS29mZmY0ePBgWrp0Kf311186YXo9d+4cz6c5d+5cbYukU+i90iipk9maNWto3LhxZGtrS0KhkPr27csdn5+fT8uXL+dFvUhMPvrg/JIuJGdra0tv377Vqjy5ubm85byuoymnsjT5+fm8KrEAaNWqVTo3qy4L6cjDHTt2KH3+27dvKSYmhvz9/WnUqFHUvHlzhfwjrVq1ojFjxtCGDRsoMTGR3r17p4G7K50TJ07wlN7GjRsrXAZd5UN9UA16xLVr1xAZGYns7GxYWVmhU6dOMDIyQn5+PurUqYOWLVsiNzcXPXv2BADExMTgu+++Q2pqKneNJk2aYNOmTXB3d9fWbSjF6tWrERMTg+TkZNy4cQMzZszAzp07tSaPPpUQAYoLA+bk5CAiIgKvXr2Cs7NziZUBMjMzERsbi7S0NAwYMAAODg4Kj2FoaIh9+/bho48+wi+//AIAWLBgAbKysuDv76/TuSzSlLdoYa1ateDi4gIXFxdu39OnT3HhwgWcP3+e216+fMk779atW7h16xb27dsHoLiTYIcOHeDk5MRtdnZ2Gv0chwwZgi1btuC7774D8L8KEtLdPRnF6I3SOHfuHCIiImBvbw9PT0+ZL36fPn24L35SUhKioqKwYcMG7u8GBgbw9vbGzz//jNq1a1e0+CpjZGSEsLAwdOrUCW/fvsWuXbvQr18/jBkzRivy6EsJEWm6deuGOnXqIDIyEsHBwbCysoK1tTU34bh9+zYyMjJgYmKCzz//XCmFIUEoFGLDhg2wsLDAjz/+CKC4/tnTp0+xc+dOleuTVSSayAo3MzPDoEGDMGjQIAAAEeH27ds8JXLx4kVe6ZSioiIkJSUhKSkJQUFBAIrL7XTp0oWnSKysrNQio4TJkyfj4cOHWLFiBYgIY8aMgbm5OZydndU6jr6jF0rj2rVriIiIQI8ePUqtIWRpaYlRo0YhKioKCQkJcHBwwLVr1+Dk5IRt27ahY8eOFSu4mrCxsUFQUBDGjh0LAPjuu+/QtWtXrtBhRaIvJUQ+xMHBAfb29khPT8d///2H5ORk5Ofnw8jICObm5vDy8oKNjU25ZrMCgQCLFi2CmZkZJk+eDLFYjH379uH58+c4cuQIatWqpcY7Uj8VUbRQIBCgVatWaNWqFb744gsAQEFBAVJSUniK5Pr167zikDk5OTh9+jROnz7N7bO0tOQpkc6dO8PU1LRc8i1btgyPHj3Cnj17kJ+fD3d3d8THx8PW1hY3b95EUlISnjx5goKCAhgaGsLCwgKOjo5o3bq13qwoy4uASLZs56xZs3SmoJdYLMaGDRtgZWUFDw8PhWoIERHCwsKQnJyMJk2aYMqUKVyxMn3mq6++wp49ewAAnTp1QkJCgsoVUVXl6tWraN++PYDisgw7duyo0PH1hWPHjsHLy4ubQTs5OSE8PBwNGzbUsmTyycnJgYmJCYDilbv0C7qiyc7ORlJSEk+RPHr0qNRzBAIB7OzseIqkffv2Sq/yCgsLMXjwYERGRgIAevXqhSFDhuDt27elrlLd3NxUWqXqOh/qA51faUiKznl5eSlVdK5nz564ceMG+vfvXykUBgBs2rQJiYmJuHnzJi5evIiFCxdWuHLX15VGRTNs2DBERkbC3d0db968wfnz5+Hs7IzIyEg0bdpU2+KVSO3atWFsbIz3799rvf6UiYkJ+vTpgz59+nD7MjMzZfwj2dnZ3N+JCKmpqUhNTeUmV4aGhvj444/h5OSErl27wsnJCa1atSr1XVK9enUcPnwYvXr1gpGREfr06YPGjRvDxcVFrlk8Li4Ohw8fRk5ODrp166bmT0PHUMRbrk00maCljyQnJ3N5ElAgNFLdnD17loUmKsHly5dlssfVlYynCSQlYho0aKBtUcpEEkm5Z88emjZtGnXp0oVr7VvaVq9ePXJzc6PFixfTiRMn6MmTJyVePzY2VuORd/qA3kVPPXnyBJ06dVLpXGtrayQnJ6tZIu3SsWNHBAQEYMaMGQCKTVaXL19Wu1NQHtIrDX1xhGuT9u3bIz4+HgMGDEB6ejoyMjLg4uKCP//8Ez169NC2eDKYm5vj/v37ePHiBYqKilCtmu6+IoRCIezs7GBnZ4dx48YBKO4pcvnyZd5q5MaNG7zzXr16hcjISM78BABNmzblrUY6duyICxcuwM7OTqleLC9fvuR6uFRWH4fO31VBQUG5Opmp2tBGl5k2bRqGDh0KAHjx4gXGjBlTYWXU9S3kVhdo0aIF4uLi4OjoCKD4peXq6orw8HAtSyaLtDP82bNnWpRENYyMjODk5ITp06fjt99+Q1paGvciX758Odzd3Xn3KOHBgwc4fPgw5s6di169eqFr167Izs5Gz549VerFkp6eru5b0xl0XmmUt5NZRTuKKwKBQICdO3eiSZMmAICzZ89ixYoVFTI2W2mohpmZGc6cOQNXV1cAxcp36NChnO1dVyhvroYuUq9ePZkuhhIlMW/ePPTq1Usmsq1Lly4wNzcvVy+WyorOK43ydDK7fft2ibOKykD9+vWxf/9+bgn8888/IyYmRuPjspWG6tSpUwfh4eHw9PQEUNx7/KuvvsLatWu1LNn/qOwd/IDiSZd0F8Po6Gi8efMGV69exa+//orJkyejWbNmsLW1Ven61tbWlfazA/RAaZSnk1lGRgY6d+6sIcm0j7OzM37++WcAxaHJX3zxBV68eKHRMdlKo3wYGhpi//79nE8KAObNm4c5c+ZotPe4olREroYuYmBgwHUx3Lp1K2rWrMnM4nLQeaXRunVrmJiYIC4ujpfsUxpEhNjYWJiamsLGxkbDEmqXhQsXcmGJGRkZ+PrrrxX+nFSBrTTKjyR7fPny5dy+gIAAjB8/HoWFhVqUrGqsNBSBmcXlo/NKQygUws3NDampqYiKiirzhUhEiIqKQlpaGvr3719pIxgkGBgYICQkhEsa++OPP7j6R5pAH8uI6CICgQA//vgjtm/fzj2jISEhGDp0KHJzc7UmF1MaxTCzuHz04o3q4OCAAQMGICEhAYcOHZJrqsrMzMTBgweRkJCgdNE5fcbS0pLnUJ07dy4uXryokbFYcp96mThxIg4fPszNTE+dOoV+/fpp3Mwoj8roCFcFZhaXj+4GYX9ARRSd02cGDhyI2bNnIyAgAAUFBfDy8kJSUhLq1Kmj1nHYSkP9DB8+HBEREXB3d0d2djb+/fdfODs7IyIiosKzx6uqT+NDpM3iypQvqgpmcb1YaUhwcHCAt7c3vLy8UKNGDSQnJ+Ps2bNITk5GjRo14OXlBW9v7yqnMCT4+flxM5z09HRMmzZN7WOwlYZm6NWrF2JiYmBhYQEASEtLwyeffILr169XqBz16tXjEvqq8kqDmcXlozcrDQlCoRC2trYqh8NVZgwNDREaGoqPP/4YOTk52Lt3L1xdXblsWXXAVhqao0OHDkhISICbmxtu3bqFR48ewdnZGeHh4ejevXuFyCAUCmFmZobMzMwqrTSAiunFoo/ondJglI61tTW2b9+O0aNHAwCmTp2Krl27qk3JspWGZmnRogXi4+MxcOBAJCUl4dWrV+jXrx8OHTrE9aTQNBKl8fTpU4jF4ko9ay4LZhaXpeo+DZUYLy8vTJgwAQCQm5sLLy8v3su+PLCQW80jyR7v168fgP9lj//2228VMr7EryESifDq1asKGVOXYWZxPmylUUnZsGEDEhISkJqaikuXLmHevHnYuHFjua/LkvsqBkn2+Lhx43Dw4EGIRCKMHz8eWVlZmDt3rkbH/jDstkGDBhodTx9gZvH/wVYalZRatWohLCyMC+X85ZdfcPz48XJfl600Kg4jIyMcOHAA06dP5/ZVRPY4y9VglAZTGpWYdu3aYf369dzvX3/9NR4+fFiua7KVRsUiFAqxceNGLFu2jNsXEBCAr776SmPZ4yxXg1EaTGlUciZPnoyRI0cCKC7J/cUXX6CoqEjl60lWGoaGhlXaQVqRCAQCLF68GNu2beM+871792LYsGEayR5nKw1GabBvfSVHIBAgODgYzZo1AwDExcVh6dKlKl9PojTYKqPimTRpEg4dOsSZHE+ePAlXV1e1Z4+zBD9GaTClUQWoV68eDhw4wPVKX758Oc6cOaPStSTmKebP0A4jRoxAREQETExMAADnzp2Di4tLuc2O0rCVBqM0mNKoInTv3p2rqkpEGDNmjEqd2dhKQ/t8mD2empqKHj16IDU1VS3XZz4NRmkwpVGFmDdvHtc57vHjxxg/frzSUThspaEbdOjQAfHx8WjVqhUAcNnjiYmJ5b72Rx99xNVaYkqD8SFMaVQhhEIh9u7dy80kT506xYuuUgS20tAdWrZsibi4OHz88ccAgJcvX6Jfv344efJkua5brVo1LjeD+TQYH8KURhXDwsICe/fu5X5fsGABLly4oNC5IpGIC/NkKw3dwNzcHNHR0ejbty+AYqXu7u7O+x+rel2geKWhyaZeDP2DKY0qiJubG+bPnw8AKCwshJeXF7Kzs8s8j9Wd0k1MTExw8uRJeHh4AChW7uPGjUNAQIDK15SsRt+/f4+cnBy1yMmoHDClUUVZtmwZunbtCgC4c+cOJk+eXOaMkiX26S6S7PGpU6dy++bMmYN58+aptFJgEVQMeTClUUWpXr06Dhw4AFNTUwBAaGgodu7cWeo5rISIbmNgYIBNmzbh559/5vatXbsWX3/9tdLZ4yxXgyEPpjSqMC1atEBwcDD3+4wZM0pt+sNWGrqPQCCAj48Ptm7dymWP79mzB8OHD0deXp7C12ErDYY8mNKo4nh4eGDy5MkAilcSnp6evBWFNGyloT9MnjwZhw4dgqGhIQAgPDwcrq6uePnypULnM6XBkAdTGgysW7cObdu2BQCkpKRg1qxZJR7HVhr6xYfZ44mJiXBxccGjR4/KPJcl+DHkwZQGAzVq1EBoaCi3eti6dSsOHz4scxxbaegfvXv3xtmzZ7mVw/Xr1xXKHmc+DYY8mNJgACjuTibdpOnbb7/FvXv3eMew/uD6SceOHREfHw9ra2sAwMOHD+Hs7Ixz587JPYeZpxjyYEqDwTFhwgR4enoCAN68eYPRo0fzom5Ynob+Ym1tjfj4eJns8VOnTpV4PDNPMeTBlAaDQyAQYNu2bWjRogWA4gqqPj4+3N/ZSkO/+TB7PC8vD+7u7ggJCZE51tjYmPOFMKXBkIYpDQYPU1NThIaGolq14vbxq1atQkREBNLS0vDgwQMsWLAAixcvRl5eHvbt24e0tDSNth5lqBdJ9vjnn38OACgqKsLYsWMRGBgoc6zERMV8GgxpqmlbAIbu4eTkhJUrV2Lu3LlwcHDAmTNnUKNGDTRq1AhdunSBkZER8vPzcfv2bYSFhcHExARubm5wcHDQtugMBTAyMkJoaChmzJiBoKAgAMDs2bORlZWFVatWgYhw8+ZNfPbZZxg5ciSqVauGgIAAWFhYwNHREa1bt2ZdG6swTGkwSmTWrFm4du0amjdvDjs7O7i4uMDS0pJ3TJ8+fZCZmYm4uDgcPnwYOTk56Natm5YkZiiDgYEBNm/eDHNzc/j6+gIA1qxZg7dv36JVq1bIzs5GmzZt0Lp1azZJYPBgSoNRIqmpqWjevDl69OgBV1dXrr/Ch1haWsLDwwNRUVGIiIhAnTp12MtETxAIBFiyZAnMzc0xdepUdO3aFWZmZrC0tISnpyebJDBKhCkNhgxisRiRkZGwt7cvVWFIEAgEXLax5DxmvtAfvvvuO1SvXh2PHj1ikwRGmbBvNkOGmzdvIjs7Gy4uLmUqDAkCgQAuLi7Izs5Genq6hiVkqBOxWIzs7GzY2dkpNUmws7NDZGQkC4SoYjClwZAhKSkJVlZWaNSokVLnWVpawsrKCv/995+GJGNoAskkoWfPnmySwCgTpjQYMjx58oTLHlYWa2trFtevZ7BJAkMZmNJgyFBQUAAjIyOVzpVE2jD0BzZJYCgDUxoMGQwNDVV+8efn56uscBjagU0SGMrAlAZDBgsLC9y+fVulc2/fvs0rdsfQfdgkgaEMTGkwZHB0dERGRgYyMzOVOi8zMxMZGRno3LmzhiRjaAI2SWAoA1MaDBlat24NExMTxMXFgYgUOoeIEBsbC1NTU9jY2GhYQoY6YZMEhjIwpcGQQSgUws3NDampqYiKiipTcRARoqKikJaWhv79+7PEPj2DTRIYysC+3YwScXBwwIABA5CQkIBDhw7JnYVmZmbi4MGDSEhIwIABA1h2sB7CJgkMZWBlRBhy6datG+rUqYPIyEgEBwfDysoK1tbWvAJ2GRkZMDExweeff84Uhh7j4OCAnJwcRERE4NWrV3B2dpapPQUUTxJiY2ORlpbGJglVFKY0GKXi4OAAe3t7pKen47///kNycjIXMWNubg4vLy/Y2Niw2WYlgE0SGIrAlAajTIRCIWxtbWFra6ttURgahk0SGGXBlAaDweDBJgmM0mDTBQaDwWAoDFMaDAaDwVAYpjQYDAaDoTBMaTAYDAZDYZjSYDAYDIbCMKXBYDAYDIVhSoPBYDAYCsOUBoPBYDAUhikNBoPBYCgMUxoMBoPBUBimNBgMBoOhMExpMBgMBkNhmNJgMBgMhsIwpcFgMBgMhWFKg8FgMBgKw5QGg8FgMBSGKQ0Gg8FgKAxTGgwGg8FQGKY0GAwGg6EwTGkwGAwGQ2GY0mAwGAyGwjClwWAwGAyFYUqDwWAwGApTraSd9+7dw6xZsypaFgaDwWDoGPfu3eP9LiAi0o4oDAaDwdA3mHmKwWAwGArDlAaDwWAwFIYpDQaDwWAozP8BqvL7xACVQicAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 500x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9b6d64313faa4316842e6b5358d5045a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/20 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/yukun/anaconda3/lib/python3.9/site-packages/sklearn/manifold/_t_sne.py:982: FutureWarning: The PCA initialization in TSNE will change to have the standard deviation of PC1 equal to 1e-4 in 1.2. This will ensure better convergence.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 500x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams['font.size'] = 28\n",
    "\n",
    "def run_t_sne(model, env, perp=12, early_exaggeration=3, learning_rate=20, start=None, goal=None):\n",
    "    data = model.Q.data.T.cpu().numpy().astype(float)\n",
    "    \n",
    "    N_nodes = env.adj_matrix.cpu().shape[0]\n",
    "    tsne = TSNE(2, perplexity=perp, init='pca',\n",
    "                early_exaggeration=early_exaggeration, learning_rate=learning_rate)\n",
    "    data_2d = tsne.fit_transform(data)\n",
    "    adjacency = env.adj_matrix.cpu().numpy()\n",
    "    if start == goal == None:\n",
    "        G = nx.from_numpy_matrix(adjacency, create_using=nx.Graph())\n",
    "    pos = {}\n",
    "    for i in range(N_nodes):\n",
    "        pos[i] = data_2d[i]\n",
    "\n",
    "    if start!= None and goal!=None:\n",
    "        fig, ax = plt.subplots(figsize=(10,8.5),dpi=300)\n",
    "        G = nx.from_numpy_matrix(adjacency, create_using=nx.DiGraph())\n",
    "        edge_colors = []\n",
    "        do_not_show = []\n",
    "        with torch.no_grad():\n",
    "            delta = model.Q[:,goal] - model.Q[:,start]\n",
    "            utility = model.W@delta\n",
    "            for edge in G.edges:\n",
    "                index = env.dataset.action_indices[(edge[0],edge[1])]\n",
    "                if utility[index]<0:\n",
    "                    do_not_show.append(edge)\n",
    "\n",
    "                else:\n",
    "                    edge_colors.append(utility[index].item())\n",
    "            for edge in do_not_show:\n",
    "                G.remove_edge(edge[0],edge[1])\n",
    "    else:\n",
    "        fig, ax = plt.subplots(figsize=(10,10),dpi=50)\n",
    "    \n",
    "    # Draw nodes\n",
    "    nodelist = list(range(0,N_nodes))\n",
    "    if start != None:\n",
    "        nodelist.remove(start)\n",
    "        nx.draw_networkx_nodes(G, pos, nodelist = [start], node_color='black',\n",
    "                           edgecolors='gray', node_size=1000, linewidths=2)\n",
    "    if goal != None:\n",
    "        nodelist.remove(goal)\n",
    "        nx.draw_networkx_nodes(G, pos, nodelist = [goal], node_color='black', node_shape='*',\n",
    "                           edgecolors='gray', node_size=2000, linewidths=2)\n",
    "        \n",
    "    \n",
    "    \n",
    "    nx.draw_networkx_nodes(G, pos, nodelist = nodelist, node_color='white',\n",
    "                           edgecolors='gray', node_size=500, linewidths=2)\n",
    "    # Draw edges\n",
    "    if start!=None or goal!=None:\n",
    "        nx.draw_networkx_edges(G, pos, edge_color=edge_colors, edge_cmap=plt.cm.rainbow, width=3,arrowsize=25)\n",
    "        sm = plt.cm.ScalarMappable(cmap=plt.cm.rainbow, norm=plt.Normalize(vmin=min(edge_colors), vmax=max(edge_colors)))\n",
    "        sm.set_array([])\n",
    "        cbar = fig.colorbar(sm, ax=ax)\n",
    "    else:\n",
    "        nx.draw_networkx_edges(G, pos, edge_color='black', edge_cmap=plt.cm.rainbow, width=4)\n",
    "    \n",
    "\n",
    "import torch\n",
    "import numpy as np\n",
    "import random\n",
    "\n",
    "def set_seed(seed=42):\n",
    "    torch.manual_seed(seed)\n",
    "    torch.cuda.manual_seed_all(seed)\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    \n",
    "epochs=20\n",
    "state_dim = 1000\n",
    "# Create the extended dataset and dataloader\n",
    "num_desired_trajectories = 200\n",
    "n_nodes = 32\n",
    "batch_size = 32\n",
    "t_sne_learning_rate = 0.5\n",
    "early_exaggeration = 2\n",
    "perp = 16\n",
    "set_seed(0)\n",
    "# torch.cuda.empty_cache()\n",
    "env = GraphEnv(n_nodes)\n",
    "model = Agent(env.size, env.n_actions, state_dim)\n",
    "\n",
    "dataset = RandomWalkDataset(env.adj_matrix, batch_size, num_desired_trajectories)\n",
    "dataloader = DataLoader(dataset, batch_size=1, shuffle=True)  # Each batch is already of size 'batch_size', so DataLoader batch_size=1\n",
    "\n",
    "\n",
    "run_t_sne(model,env,perp,early_exaggeration,t_sne_learning_rate)\n",
    "plt.show()\n",
    "loss_record = train_model(model, dataloader, epochs, norm=False)\n",
    "run_t_sne(model,env,perp,early_exaggeration,t_sne_learning_rate)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "d0d28b68",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "71d8c5cf658c432ebaf1594a9e0a7a6b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "rounds:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  0 state dim:  10\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8fffe4eed79a4d2180c99f09fc654ccb",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "90ece6b8008d4e85897d2553c7a18adf",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  0 state dim:  20\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "aad40c8875b44593b49ce018db286538",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2dae42920854462fa45d2b3433dcdc85",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  0 state dim:  50\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "47aaad66cfaf49d386335c38b55f667b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "30027709476948faa12adc6b3feffe24",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  0 state dim:  100\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "dffcca4d48ea49e09d20eb571e923174",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e218cd84690a45b0b8132503c2fb11ca",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  0 state dim:  200\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a5c1ffde2519456eb970ddd6ccb0775a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "73da3d632df643c98407f751e94ee31b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  0 state dim:  500\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "35131fb4c95b4e869b4564c04998f56d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b36e4cca81d648a380933c38e6faefe2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  0 state dim:  1000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "73009df0def64bbd8858c3019527ee27",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2f72e45c677143dbbf8dab3046c664c4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  0 state dim:  2000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0429f8cbcfca4bffb769b646a6bac478",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6e34e1d251a44ec9aa03c57bb51334ca",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  0 state dim:  5000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "94dbcc3a077a4093bf24cfe40030882b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "42f0e78b1187437da9f193b640901068",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  0 state dim:  10000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b1ed76ad60c34b06b360bb15a15e155a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1b904d8f98d648018ea62859f1b204cf",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  1 state dim:  10\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7400af2e7cb64187855aa3b40d2d3051",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1698b628660b4fca89909ac7ecd1e065",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  1 state dim:  20\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a64a6aadc32b4172b62c9c7d79547db6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e852f74075d548d2b0a77361502b39aa",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  1 state dim:  50\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4d95174869a64f729e4bcbbc53f403d1",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2de2cb8deea6405090abd74336b8ab5c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  1 state dim:  100\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b6795be4daba428480090bf5902210aa",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "09fec33c77b64a47809d61c0ac1105bb",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  1 state dim:  200\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b3d2e771097b44eb849ff3ce41f2a307",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "714b020181624809b6f41c01d733250d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  1 state dim:  500\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "224fff33a588496ab067aa2ccd1e9bdc",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "94147c1d4c044f2980318522a5864f35",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  1 state dim:  1000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "04fe3fa035e44e6282cbe6807e8e23bd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2215ab522ec94832be7fc8e343f56d13",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  1 state dim:  2000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "93b7a10759ec4939b30f6fd25e6a554e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2c1e19621916478ebb40f4b69dea214f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  1 state dim:  5000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7306f3abd5074bbbab589e144c65a60e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e2d092b7d8dc4b60b0e2bdda40056612",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  1 state dim:  10000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0e69409d6c6c49fea534a1715b1dee7e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "63b4c69f5d264b97b23e6d1abdc10ba6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  2 state dim:  10\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c9cb60fcbb704354aeffebbe46aef06e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b6f782f3a8c84fbcbb628162b8af80b4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  2 state dim:  20\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "456fa09d031b4d2a8745859c3e68d082",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1a6097f15b074290bd02aa409f1c0c88",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  2 state dim:  50\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4e284d9b425441d3b058a5802f343fbe",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "851b4e63f08f4c70a795a937356edc83",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  2 state dim:  100\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "df807c3934224d28b17ec3ed65f514f7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "39c4102dc7b6462aa56f0a32d20caa9a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  2 state dim:  200\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "da6b6a27faeb4353bb3fa4840294c096",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6db8f0c21ade4822985ecfc20f890034",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  2 state dim:  500\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1da7fa39b2e04b7aa4f498f5b3d31fe2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f3de08fc247d474caabe5a862effebc1",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  2 state dim:  1000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "42d9957a5f8340158a83178f5566c55b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "23b7d7a1da5742d6b2c5d5e59cb05efd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  2 state dim:  2000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e2cbaf6969614c28bf09d42334d530cb",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "432bf3a988eb406983d1ae501ed4e52c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  2 state dim:  5000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6ce7f50560474c1aa4f241a0b1ead39f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9f546bec8f68459092a779f343c76402",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  2 state dim:  10000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2fd291434cf64211ae43610ea56cdd77",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "73c75ea64ce84cae8a07201c08a82662",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  3 state dim:  10\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "86ae33d7c44942b7927c6f780b3a3de3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "abbd222f57d146069abdf352aef6c0e4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  3 state dim:  20\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3f2d0d641d2a42278d2bd599a1156df3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fd3ed0961aa74cbead11afb6627bc72f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  3 state dim:  50\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0be4c88a0ede4d329e473b7ce750f616",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ac15de2f98aa43d283f5bf9cab0b15fc",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  3 state dim:  100\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e7277984cbce44d3b976ab2d3ee2fe20",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ee1a723e38134751b53a6ca745aa8637",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  3 state dim:  200\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ae3e510900aa411db5940fbedf48e683",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "585d7bcac56f4418b66db17e79d7c2d9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  3 state dim:  500\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "cac9cc906f3c46ad9ecfb0dc2d3a8f97",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d36b2dcf33d140ddbe823c59c6ce47a1",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  3 state dim:  1000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "10167646e927457084e5c526c29567c2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7bef5582eea94dd394787f3904ab3bba",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  3 state dim:  2000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "662412151b2d4505a0c7ca62494e74c4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f6814cd017a344c89c658a813aa7f721",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  3 state dim:  5000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "56ff6a69e1d7404491a9ec297ba47ad8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "22b9d8f60242404882154662382d45db",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  3 state dim:  10000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "eca3e9da13f247c093967d26b81eba2a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ea1a02993f224371b92115dd3adce3dc",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  4 state dim:  10\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "43e2ca64e01248edb3380b33d822608e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7eafb29527344a099594f054b37417b7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  4 state dim:  20\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2b4446c4ed6e41b8ab7c5d498b9f9112",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c7057d6581b846a892f32f090e014a00",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  4 state dim:  50\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1302b38f2fa44e7e92b772e87abf4e30",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f1b5706706ef404ba4adbc75dca4dc95",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  4 state dim:  100\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6d09ca1912ea4dc4a806b5d6233ab437",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0a5d069844794b6aba3c030dc86f1154",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  4 state dim:  200\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "43e0b1a4324c4410af432122b4278e1f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a0d30d2e4b9446c983e6e39e8c34a56f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  4 state dim:  500\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "043c1a8d846942d6951c12dc2d35e22e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e736652d7f9f43e28ad5909630e0900c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  4 state dim:  1000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2843a09ead544c43a2e0d2c1d860e58b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1fef67074a524f488975fa75679b8fdb",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  4 state dim:  2000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "cc75ad36254b4d90be663646a4c906d3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b61a6ba8aa2444b0936dc3ebb82b3ed5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  4 state dim:  5000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4dbe3b9d85b947c9a8baa17a2973afc7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6603ea0dfc3c4fc49b512312b6e0c17f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  4 state dim:  10000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "198027e1122b466094651d9c8e9014c4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7444563d7d3e449e89b92481b3301c3a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  5 state dim:  10\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "be99901ac9fd4c22905edf93d939e72f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6b4032afd3dd45cd853f61a923d7e79f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  5 state dim:  20\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c12f515c6e5b4812b9a2f9b658ce3772",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d7c96c4ded1a441fb3e1eb10802495fe",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  5 state dim:  50\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "96d6e4c3a5434ef6818fec812c45f6ba",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "09e0506316534e709c8c8e32b276f0da",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  5 state dim:  100\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0e8ac7a0c6e0465db4503fb1bfdf20fa",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "109f62bafb71489f90e3f7dfa8f2f897",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  5 state dim:  200\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4ecb51f5f9aa407fbae0b46277177d6a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0ca972ec86d14540b52ef29c934413bc",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  5 state dim:  500\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a1d92947f53041f5b933fede8562aa5d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "af31a10485e9496cb1840c7aae675c4f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  5 state dim:  1000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f112c597df5c4d7aa4a3972905f40293",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ca5c82580db54d6eb0079e954318b2cb",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  5 state dim:  2000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1bdc647bf0a44930b5171afccfb924a8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7a5258d484324cab99b86f0cfea135cc",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  5 state dim:  5000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d7133721ca9d4acf8b169c5cac24ff18",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e7d0c53168544ba08fa3e8371ae9d694",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  5 state dim:  10000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3a54091d91f64135be24926d621adf82",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f0faee8888694875b1c091209b3442e3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  6 state dim:  10\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0e085f74ae36419aafe48e41264b5f08",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "aafd90cf776143b7a31be1f4d055d300",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  6 state dim:  20\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "349b916493e44a649ab0b8defaa87c06",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "37ba2f427ea748e5bdf580b25dfeea5d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  6 state dim:  50\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b3c05323a06d4e63ae2c36a7ee3c383e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2e7f3ed2c526453896a67d653120bd81",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  6 state dim:  100\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3be0ffba2f834fc59ecac0a35e3c9abc",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "76af1e289b404577bcd1f102e0f46a38",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  6 state dim:  200\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "dce948d64c184aa489414520c257b1ce",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c571d90c69224bde9b2261ee61f9ee1d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  6 state dim:  500\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "17417e7309264973818df46af7bd350a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6720c29c75034d1ea9364d741aa1c5f2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  6 state dim:  1000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1edb717917ea4c4797f0161b6b8bec65",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2659fcb483374927918bc0ae79b710f2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  6 state dim:  2000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d7d9fb9597a243448fa37883a6de1171",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f4d134ca53b741718f30128215a88910",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  6 state dim:  5000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1d1f37e335d7496dbc02eba5b9066489",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d40cc787d6194877b3586cb3f456489d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  6 state dim:  10000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0a3e7e3c8d3746ea86111c72241f736d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2568323e60a44b7598f5d9d25db3bc7e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  7 state dim:  10\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3d85ddbd580543c6bf43fe9b844f53ea",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "cbe79f55ec2f49f0a3674153fd31926e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  7 state dim:  20\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "918dac361edf4070b191cb883918862c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "170c686dabbd4858aa15c7e24ce510ea",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  7 state dim:  50\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "396c53f18cec4d559a45640a6c4d06f8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3cd46b514c4a4035b30ab7dc38fede5a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  7 state dim:  100\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "19e8ff57d3c442f980ba410d972f0d22",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "07d9a1b98e1748b2a9637395854d043d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  7 state dim:  200\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "dac9c266136f4f12a4983729aceaaab4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "994ed4cef7b344e1b2839f2f1c580b34",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  7 state dim:  500\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "febe381b13b04198a9e043c2239fddd8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3cfa001ca3ea4da89c5aa0600e8f2d32",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  7 state dim:  1000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d83c9cd2bad64fcc960d8de596fc1f1a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d6322a0855c74eba8f669b6cf2109380",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  7 state dim:  2000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c06f7daf2176405bb34101cdf1ea6aa4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d5bc410a66564a2da9d028c09e98bde2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  7 state dim:  5000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "12ebd59d60da4e749b9e885ad860a1ae",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "112ce2e2d5c8444cb5e1a3b0482f5b2e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  7 state dim:  10000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "bf75654d57504a3aa143d14eecaadc98",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f01be5fec2304f3eb96db2c2610b3f50",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  8 state dim:  10\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "34260a813019453cb261ba9ed87f2f46",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "82c30669c2a24b97871106fc64fb49af",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  8 state dim:  20\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0be60daa8ffa4ec88f07e6503ac59455",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "756c8e373faf4f21a9dc76ed956a90c2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  8 state dim:  50\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d2148d9a898842d395b582d245604023",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "32a277e7b47d42ae8113f03369042cbd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  8 state dim:  100\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a2aaa56fc9f14f50abd0bddf0ab2ebc9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a0f53b63c2a84256a773b9689f2f13c6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  8 state dim:  200\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "92d93bbada6c45ad881c4eaf9b7729ef",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "def2bfff327044b6b8cc8537825cd1e6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  8 state dim:  500\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3adf74e3e89941f1a21de7ee447ce56b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "da276c6a4cea480b9ba970f639f9f0d3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  8 state dim:  1000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c30460ea61a641638886c4cfd99788af",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c9a51c2fc9b74105b286fea42e12373c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  8 state dim:  2000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "af93f12eb3644b5b8d8cb45bb02e5613",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "de2d1ec7de914f7db13e6180d77302d2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  8 state dim:  5000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a72418e78ad3443591413f25120d0b8d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1549472afd7143efa721592d760331ca",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  8 state dim:  10000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "242a3d64153f483cb146fd7651cf202e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "47471abc69fd4761857e69dba1001454",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  9 state dim:  10\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d5f722b5ca0648e5981e91fd4787eedb",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fd1a776e68734d73acd67d76f0e887a2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  9 state dim:  20\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "47552b9dd1c1426fb9f9056c485d59bc",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6d80ce27d4da46fb871daa2661bb5e33",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  9 state dim:  50\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0a859b11b15c4d0eafbe1714d13ce850",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c4e0beccc9fe41b6a1f11da4a032dcd7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  9 state dim:  100\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "219ace6307b14b5b81447c62d9e20832",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "30faa2c956984c6fb82100d482183022",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  9 state dim:  200\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d5b0a4528e2240c4ab71d03b02d42838",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8906de88e246417890493e6ee79bdfaf",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  9 state dim:  500\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b67ea575cea94117856bb2418c8db618",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5316902a5dbe4cb4979524e7350321ad",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  9 state dim:  1000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "847b2751fb04427a9f0381600b16a63d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2147678480e64184aa923037dd7928a2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  9 state dim:  2000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b5368680cae1482e9b2b72a9cdf3ffd2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ed0ebbd415cd478cb20bf5fa07ba10b0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  9 state dim:  5000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d69812738b28459fbac3387aacc24e1d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0671d18b8bcb453c94674b957abbee26",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  9 state dim:  10000\n",
      "without normaliztion on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0e1b38b3881b4d37b5f5f41f94040d56",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with normalization on V\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "aeeb1beacdab45ba882224754c4be940",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epochs:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_nodes = 32\n",
    "batch_size = 32\n",
    "state_dims = [10,20,50,100,200,500,1000,2000,5000,10000]\n",
    "epochs = 10\n",
    "\n",
    "num_desired_trajectories=200\n",
    "repeats = 10\n",
    "all_means = []\n",
    "all_means_norm = []\n",
    "env = GraphEnv(n_nodes, env='random')\n",
    "for r in tqdm(range(repeats), desc=\"rounds\"):\n",
    "    means = []\n",
    "    means_norm = []\n",
    "    for state_dim in state_dims:\n",
    "        print('round: ', r, 'state dim: ', state_dim)\n",
    "    # choose env from \"random\", \"small world\" or \"dead ends\"\n",
    "#         env = GraphEnv(n_nodes, env='random')\n",
    "        dataset = RandomWalkDataset(env.adj_matrix, batch_size, num_desired_trajectories)\n",
    "        dataloader = DataLoader(dataset, batch_size=1, shuffle=True)\n",
    "        model = Agent(env.size, env.n_actions, state_dim)\n",
    "        print('without normaliztion on V')\n",
    "        loss_record = train_model(model, dataloader, epochs, norm=False)\n",
    "        mean_CML = test_model(model, env, False)\n",
    "        means.append(mean_CML)\n",
    "        \n",
    "        model = Agent(env.size, env.n_actions, state_dim)\n",
    "        print('with normalization on V')\n",
    "        loss_record = train_model(model, dataloader, epochs, norm=True)\n",
    "        mean_CML_norm = test_model(model, env, False)\n",
    "        means_norm.append(mean_CML_norm)\n",
    "        \n",
    "    all_means.append(means)\n",
    "    all_means_norm.append(means_norm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "58936216",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1800x900 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# import seaborn as sns\n",
    "all_means = np.array(all_means)\n",
    "mean = all_means.mean(axis=0)\n",
    "std = all_means.std(axis=0)\n",
    "\n",
    "all_means_norm = np.array(all_means_norm)\n",
    "mean_norm = all_means_norm.mean(axis=0)\n",
    "std_norm = all_means_norm.std(axis=0)\n",
    "# Plot the fill between for the With Normalization data\n",
    "# Set seaborn default style\n",
    "# sns.set_style(None)\n",
    "\n",
    "plt.rcParams['font.size'] = 22\n",
    "plt.figure()\n",
    "fig, axes = plt.subplots(1, 1, figsize=(6, 3), dpi=300)\n",
    "\n",
    "\n",
    "axes.fill_between(state_dims, \n",
    "                  mean_norm - std_norm,\n",
    "                  mean_norm + std_norm,\n",
    "                  color='tab:blue', alpha=0.2)\n",
    "\n",
    "axes.plot(state_dims, mean_norm, '-o', alpha=.9, color='tab:blue', lw=3, label='with normalization')\n",
    "\n",
    "axes.fill_between(state_dims, \n",
    "                  mean - std,\n",
    "                  mean + std,\n",
    "                  color='tab:orange', alpha=0.2)\n",
    "\n",
    "axes.plot(state_dims, mean, '-o', alpha=.9, color='tab:orange', lw=3,label='w/o normalization')\n",
    "\n",
    "axes.legend()\n",
    "axes.set_xscale('log')\n",
    "axes.spines['top'].set_visible(False)\n",
    "axes.spines['right'].set_visible(False)\n",
    "\n",
    "axes.xaxis.set_ticks_position('bottom')\n",
    "axes.yaxis.set_ticks_position('left')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dfe200b3",
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}