Sequential_D3PM.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/pberlure/miniconda3/envs/jupyter_env/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import networkx as nx\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import torch\n",
    "from torch import nn\n",
    "from torchvision.ops import MLP\n",
    "import torch_geometric\n",
    "from torch_geometric.data import Data, Dataset\n",
    "from torch_geometric.transforms import BaseTransform, AddLaplacianEigenvectorPE\n",
    "from torch.nn import functional as F\n",
    "import torch_geometric.utils as U\n",
    "from torch_geometric.utils.convert import to_networkx, from_networkx\n",
    "from torch_geometric.utils import to_dense_batch, remove_self_loops, k_hop_subgraph\n",
    "import random\n",
    "from copy import deepcopy\n",
    "import os\n",
    "import os.path as osp\n",
    "from tqdm import tqdm\n",
    "from itertools import combinations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def wilson_algorithm(G, start):\n",
    "    \"\"\"\n",
    "    Wilson's algorithm for generating a uniform spanning tree on a graph.\n",
    "\n",
    "    Parameters:\n",
    "    - G: NetworkX graph\n",
    "    - start: starting node for the algorithm\n",
    "\n",
    "    Returns:\n",
    "    - T: Uniform spanning tree of G\n",
    "    \"\"\"\n",
    "    U = {start}\n",
    "    T = deepcopy(G)\n",
    "    nx.set_edge_attributes(T, {e:{\"edge_weight\":0.} for e in T.edges(data=False)})\n",
    "    nx.set_node_attributes(T, {n:{'pos':n} for n in T.nodes(data=False)})\n",
    "    while len(U) < len(G.nodes):\n",
    "        u = random.choice(list(set(G.nodes) - U))\n",
    "        path = [u]\n",
    "        while u not in U:\n",
    "            u = random.choice(list(G.neighbors(u)))\n",
    "            if u in path:\n",
    "                cycle_index = path.index(u)\n",
    "                path = path[:cycle_index + 1]\n",
    "            else:\n",
    "                path.append(u)\n",
    "        U.update(path)\n",
    "        nx.set_edge_attributes(T, {(path[i], path[i + 1]):{\"edge_weight\":1.} for i in range(len(path) - 1)})\n",
    "    return T\n",
    "\n",
    "def generate_ust_maze(width, height):\n",
    "    \"\"\"\n",
    "    Generates a maze using Wilson's algorithm.\n",
    "\n",
    "    Parameters:\n",
    "    - width: width of the maze\n",
    "    - height: height of the maze\n",
    "\n",
    "    Returns:\n",
    "    - T: Uniform spanning tree representing the maze\n",
    "    \"\"\"\n",
    "    G = nx.grid_2d_graph(width, height)\n",
    "    start = (random.randint(0, width-1), random.randint(0, height-1))\n",
    "    T = wilson_algorithm(G, start)\n",
    "    return T\n",
    "\n",
    "def generate_ust_maze_list(size, width, height):\n",
    "    \"\"\"\n",
    "    Generates a maze dataset\n",
    "\n",
    "    Parameters:\n",
    "    - width: width of the maze\n",
    "    - height: height of the maze\n",
    "\n",
    "    Returns:\n",
    "    - L a list of maze\n",
    "    \"\"\"\n",
    "    L = []\n",
    "    for i in range(size):\n",
    "        L.append(generate_ust_maze(width, height))\n",
    "    \n",
    "    return L\n",
    "\n",
    "def write_ust_maze_list(L, dir_name):\n",
    "    \"\"\"\n",
    "    Writes a list of mazes in a specified file\n",
    "\n",
    "    Parameters:\n",
    "    - L: list of ust mazes\n",
    "    - dir_name: The name of the directory to write the list\n",
    "    \"\"\"\n",
    "\n",
    "    for i, G in enumerate(L):\n",
    "        nx.write_gml(G, dir_name+\"/Graph_\"+str(i), stringizer=nx.readwrite.gml.literal_stringizer)\n",
    "\n",
    "def draw_maze(T, width, height):\n",
    "    \"\"\"\n",
    "    Draw the maze represented by the uniform spanning tree T.\n",
    "\n",
    "    Parameters:\n",
    "    - T: Uniform spanning tree representing the maze\n",
    "    - width: width of the maze\n",
    "    - height: height of the maze\n",
    "    \"\"\"\n",
    "    pos = {n:pos for (n,pos) in nx.get_node_attributes(T, \"pos\").items()}\n",
    "    real_edges = [e for (e,v) in nx.get_edge_attributes(T, \"edge_weight\").items() if v==1]\n",
    "    plt.figure(figsize=(10, 10))\n",
    "    nx.draw(T.edge_subgraph(real_edges), pos=pos, with_labels=False, node_size=10, width=2, edge_color='blue')\n",
    "    plt.xlim(-1, width)\n",
    "    plt.ylim(-1, height)\n",
    "    plt.gca().invert_yaxis()\n",
    "    plt.show()\n",
    "\n",
    "def draw_Data(G, width, height):\n",
    "    \"\"\"\n",
    "    Draw ther maze represented by the graph G\n",
    "\n",
    "    Parameters:\n",
    "    - G: torch_geometric graph\n",
    "    - width: width of the maze\n",
    "    - height: height of the maze\n",
    "    \"\"\"\n",
    "\n",
    "    T = to_networkx(G, to_undirected=True, node_attrs=['pos'], edge_attrs=['edge_weight'])\n",
    "    draw_maze(T, width, height)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using gpu: True \n"
     ]
    }
   ],
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "print('Using gpu: %s ' % torch.cuda.is_available())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Maze_dataset(Dataset):\n",
    "    \"\"\"\n",
    "    A class to represent a Dataset of maze\n",
    "    \"\"\"\n",
    "    def __init__(self, root, transform=None, pre_transform=None, pre_filter=None, force_reload=False):\n",
    "        super().__init__(root, transform, pre_transform, pre_filter)\n",
    "        self.pre_transform = pre_transform\n",
    "        self.transform = transform\n",
    "        self.pre_filter = pre_filter\n",
    "        self.root = root\n",
    "\n",
    "    @property\n",
    "    def raw_file_names(self):\n",
    "        return [f for f in os.listdir(self.root+\"/raw\")]\n",
    "\n",
    "    @property\n",
    "    def processed_file_names(self):\n",
    "        return [f for f in os.listdir(self.root+\"/processed\")]\n",
    "\n",
    "    def process(self):\n",
    "        idx = 0\n",
    "        for raw_path in self.raw_paths:\n",
    "            # Read data from `raw_path`.\n",
    "            raw_graph = nx.read_gml(raw_path)\n",
    "\n",
    "            data = from_networkx(raw_graph).to(device)\n",
    "\n",
    "            data.edge_index, data.edge_weight = torch_geometric.utils.coalesce(edge_index=data.edge_index, edge_attr=data.edge_weight)\n",
    "\n",
    "            data.edge_state = torch.hstack((data.edge_weight.unsqueeze(1), 1. - data.edge_weight.unsqueeze(1))) #Binary state space\n",
    "\n",
    "            if self.pre_transform is not None:\n",
    "                data = self.pre_transform(data)\n",
    "\n",
    "            torch.save(data, osp.join(self.processed_dir, f'data_{idx}.pt'))\n",
    "            idx += 1\n",
    "\n",
    "    def len(self):\n",
    "        return len(self.processed_file_names)\n",
    "\n",
    "    def get(self, idx):\n",
    "        data = torch.load(osp.join(self.processed_dir, f'data_{idx}.pt'))\n",
    "        return data\n",
    "    \n",
    "    def get_raw(self, idx):\n",
    "        G = nx.read_gml(osp.join(self.raw_dir, f'Graph_{idx}'), destringizer=nx.readwrite.gml.literal_destringizer)\n",
    "        return G"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#L = generate_ust_maze_list(10_000, 9, 9)\n",
    "#write_ust_maze_list(L, \"D3PM/Ddataset9/raw\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = Maze_dataset(\"D3PM/Ddataset32\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_2491431/2414134020.py:42: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
      "  data = torch.load(osp.join(self.processed_dir, f'data_{idx}.pt'))\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "width, height = 32, 32\n",
    "draw_Data(dataset[0], width, height)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model design"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sinusoidal_embedding(n, d):\n",
    "    \"\"\"\n",
    "    Returns the sinusoidal positional encoding of dimension d for n timesteps.\n",
    "    \"\"\"\n",
    "    embedding = torch.tensor([[i / 10_000 ** (2 * j / d) for j in range(d)] for i in range(n)])\n",
    "    sin_mask = torch.arange(0, n, 2)\n",
    "\n",
    "    embedding[sin_mask] = torch.sin(embedding[sin_mask])\n",
    "    embedding[1 - sin_mask] = torch.cos(embedding[sin_mask])\n",
    "\n",
    "    return embedding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AddEdgeStatePE(BaseTransform):\n",
    "    \"\"\"\n",
    "    A transform class to add data about adjacent edges state in each nodes' embedding\n",
    "\n",
    "    This implementation is not efficient at all it is just meant for little tests, which aren't conclusive.\n",
    "    \"\"\"\n",
    "    def __init__(self) -> None:\n",
    "        pass\n",
    "\n",
    "    def forward(self, data) -> Data:\n",
    "        assert data.edge_index is not None\n",
    "        assert data.edge_state is not None\n",
    "        assert data.batch is not None\n",
    "\n",
    "        adjacent_edges = to_dense_batch(data.edge_state, data.edge_index[0])[0] #For each node, the states of its adjacent edges (in the underlying graph)\n",
    "        adjacent_edges = torch.flatten(adjacent_edges, start_dim=1)\n",
    "\n",
    "        data.x = torch.hstack((data.x, adjacent_edges))\n",
    "\n",
    "        return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class D3PM(nn.Module):\n",
    "    \"\"\"\n",
    "    A class to represent a diffusion model using the network parameter as a denoiser.\n",
    "    \"\"\"\n",
    "    def __init__(self, network, num_hops=3, device=device):\n",
    "        super(D3PM, self).__init__()\n",
    "        self.num_hops = num_hops\n",
    "        self.edges_transform = AddEdgeStatePE()\n",
    "        self.network = network\n",
    "        self.device = device\n",
    "        self.num_nodes = 4 * (2**num_hops)\n",
    "\n",
    "    def add_noise(self, G_start, thresholds):\n",
    "\n",
    "        noised_G = G_start.clone()\n",
    "        \n",
    "        noised_indices = (noised_G.x[noised_G.edge_index[0]][:,0] < thresholds[noised_G.batch[noised_G.edge_index[0]]]) | (noised_G.x[noised_G.edge_index[1]][:,0] < thresholds[noised_G.batch[noised_G.edge_index[1]]])\n",
    "        sample = torch.randint(low=0, high=2, size=(noised_G.edge_state.shape[0],), device=self.device).long()\n",
    "        \n",
    "        noised_G.edge_state[noised_indices] = F.one_hot(sample, 2).to(torch.float32)[noised_indices]\n",
    "\n",
    "        undirected_indices = (noised_G.edge_index[0] < noised_G.edge_index[1]) * noised_G.csr()[2] + (noised_G.edge_index[0] >= noised_G.edge_index[1]) * noised_G.csc()[2] # To noise in a undirected way. \n",
    "        noised_G.edge_state[undirected_indices] = noised_G.edge_state[undirected_indices]\n",
    "        \n",
    "        noised_G.edge_weight = noised_G.edge_state[:,0]\n",
    "        \n",
    "        return noised_G\n",
    "\n",
    "    def reverse(self, batch, thresholds):\n",
    "        batch.x = F.one_hot((batch.x[:,0] < thresholds[batch.batch]).long(), num_classes=2).to(torch.float32)\n",
    "        batch = self.edges_transform(batch)\n",
    "\n",
    "        pos = (torch.arange(batch.num_nodes, device=device) % batch.ptr[1]) % self.num_hops\n",
    "        \n",
    "        batch.x = torch.cat([F.one_hot( pos, num_classes=self.num_hops).to(torch.float32), batch.x], dim=1)\n",
    "        \n",
    "        res = self.network(batch.x, batch.edge_index)\n",
    "\n",
    "        return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Network(nn.Module):\n",
    "    \"\"\"\n",
    "    A basic GNN model to denoise in the diffusion process.\n",
    "    \"\"\"\n",
    "    def __init__(self, max_deg=4, num_gcn_layers=3, num_mlp1_layers=2, num_mlp2_layers=2):\n",
    "        super().__init__()\n",
    "        self.feature_size = 2 + 2*max_deg + num_gcn_layers\n",
    "        self.mlp1 = MLP(in_channels=self.feature_size, hidden_channels=[2*self.feature_size for _ in range(num_mlp1_layers)])\n",
    "        self.GNN = torch_geometric.nn.GCN(in_channels=2*self.feature_size, \n",
    "                                          hidden_channels=4*self.feature_size, \n",
    "                                          num_layers=num_gcn_layers, \n",
    "                                          out_channels=4*self.feature_size,\n",
    "                                         )\n",
    "        \n",
    "        self.mlp2 = MLP(in_channels=8*self.feature_size, hidden_channels=[8*self.feature_size for _ in range(num_mlp2_layers)]+[1])\n",
    "        self.sig = torch.nn.Sigmoid()\n",
    "\n",
    "        self.edges_transform = AddEdgeStatePE()\n",
    "    \n",
    "    def forward(self, x, edge_index):\n",
    "\n",
    "        y = self.mlp1(x)\n",
    "        y = self.GNN(x=y, edge_index=edge_index)\n",
    "        y = torch.cat((y[edge_index[0]].T, y[edge_index[1]].T)).T\n",
    "        out = self.mlp2(y)\n",
    "\n",
    "        return self.sig(out).reshape(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_timesteps = 1000\n",
    "time_emb_dim = 100\n",
    "batch_size = 1\n",
    "data_size = 10000\n",
    "num_gcn_layers = 3\n",
    "num_mlp1_layers = 2\n",
    "num_mlp2_layers = 2\n",
    "\n",
    "graph_size = width * height\n",
    "\n",
    "network = Network(max_deg=4, num_gcn_layers=num_gcn_layers, num_mlp1_layers=num_mlp1_layers, num_mlp2_layers=num_mlp2_layers)\n",
    "\n",
    "model = D3PM(network, num_hops=num_gcn_layers, device=device)\n",
    "#model.load_state_dict(torch.load('model_weights2.pth', weights_only=True))\n",
    "\n",
    "train_loader = torch_geometric.loader.DataLoader(dataset[:data_size], batch_size=batch_size, shuffle=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda:0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|                                                   | 0/100 [00:00<?, ?it/s]/tmp/ipykernel_2491431/2414134020.py:42: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
      "  data = torch.load(osp.join(self.processed_dir, f'data_{idx}.pt'))\n",
      "  3%|█▎                                         | 3/100 [00:51<27:52, 17.24s/it]\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[13], line 47\u001b[0m\n\u001b[1;32m     44\u001b[0m         loss\u001b[38;5;241m.\u001b[39mbackward()\n\u001b[1;32m     45\u001b[0m         optimizer\u001b[38;5;241m.\u001b[39mstep()\n\u001b[0;32m---> 47\u001b[0m         losses\u001b[38;5;241m.\u001b[39mappend(\u001b[43mloss\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mitem\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[1;32m     48\u001b[0m         accs\u001b[38;5;241m.\u001b[39mappend(acc)\n\u001b[1;32m     50\u001b[0m torch\u001b[38;5;241m.\u001b[39msave(model\u001b[38;5;241m.\u001b[39mstate_dict(), \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmodel_weights2.pth\u001b[39m\u001b[38;5;124m'\u001b[39m)\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "num_epochs = 10\n",
    "learning_rate = 0.001\n",
    "\n",
    "optimizer = torch.optim.Adam(network.parameters(), lr=learning_rate)\n",
    "loss_fn = torch.nn.BCELoss()\n",
    "\n",
    "losses = []\n",
    "accs = []\n",
    "\n",
    "\n",
    "print(device)\n",
    "\n",
    "model.to(device)\n",
    "for epoch in tqdm(range(num_epochs)):\n",
    "        #print(f\"Epoch {epoch}\")\n",
    "        model.train()\n",
    "\n",
    "        # inside the training loop\n",
    "        for step, batch in enumerate(train_loader):\n",
    "\n",
    "                batch = batch.to(device)\n",
    "\n",
    "                num_nodes = batch.ptr[1:] - batch.ptr[:-1]\n",
    "                \n",
    "                batch.x = torch.arange(batch.num_nodes).to(device).reshape(-1, 1).float() - batch.ptr[batch.batch].reshape(-1, 1).float()\n",
    "                thresholds = torch.randint(low=1, high=graph_size, size=(batch.num_graphs,)).to(device)\n",
    "\n",
    "                \"\"\"\n",
    "                Noising\n",
    "                \"\"\"\n",
    "\n",
    "                noisy = model.add_noise(batch, thresholds)\n",
    "                \n",
    "                \"\"\"\n",
    "                Denoising\n",
    "                \"\"\"\n",
    "\n",
    "                noise_pred = model.reverse(batch=noisy, thresholds=thresholds)\n",
    "\n",
    "                loss = loss_fn(noise_pred, batch.edge_state[:,0])\n",
    "                acc = torch.sum(((noise_pred > 0.5) == batch.edge_state[:,0]).float()) / noise_pred.shape[0]\n",
    "                \n",
    "                optimizer.zero_grad()\n",
    "                loss.backward()\n",
    "                optimizer.step()\n",
    "\n",
    "        losses.append(loss.item())\n",
    "        accs.append(acc)\n",
    "        \n",
    "        torch.save(model.state_dict(), 'model_weights2.pth')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(losses)\n",
    "plt.title(\"BCELoss\")\n",
    "plt.show()\n",
    "plt.title(\"Accuracy\")\n",
    "plt.plot(torch.tensor(accs))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_781767/922136810.py:42: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
      "  data = torch.load(osp.join(self.processed_dir, f'data_{idx}.pt'))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(0.8762, device='cuda:0')\n"
     ]
    }
   ],
   "source": [
    "model.eval()\n",
    "model.to(device)\n",
    "running_acc = 0.\n",
    "\n",
    "# inside the training loop\n",
    "with torch.no_grad():\n",
    "    running_acc = 0.\n",
    "    running_loss = 0.\n",
    "    for step, batch in enumerate(train_loader):\n",
    "        batch = batch.to(device)\n",
    "        num_nodes = batch.ptr[1:] - batch.ptr[:-1]\n",
    "        \n",
    "        batch.x = torch.arange(batch.num_nodes).to(device).reshape(-1, 1).float() - batch.ptr[batch.batch].reshape(-1, 1).float()\n",
    "        thresholds = torch.randint(low=1, high=graph_size, size=(batch.num_graphs,)).to(device)\n",
    "        \"\"\"\n",
    "        Noising\n",
    "        \"\"\"\n",
    "        noisy = model.add_noise(batch, thresholds)\n",
    "        \n",
    "        \"\"\"\n",
    "        Denoising\n",
    "        \"\"\"\n",
    "        noise_pred = model.reverse(batch=noisy, thresholds=thresholds)\n",
    "\n",
    "        running_acc += torch.sum(((noise_pred > 0.5) == batch.edge_state[:,0]).float()) / noise_pred.shape[0]\n",
    "\n",
    "    print(running_acc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sampling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Monitoring functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "def num_squares(G):\n",
    "    res = 0\n",
    "    for v in range(G.number_of_nodes()):\n",
    "        for u, w in combinations(G[v], 2):\n",
    "            if u>v and w>v:\n",
    "                squares = len((set(G[u]) & set(G[w])) - {v})\n",
    "                res += squares\n",
    "    return res\n",
    "\n",
    "def cc_and_trees(G):\n",
    "    cc = nx.connected_components(G)\n",
    "    cc = list([c for c in cc if len(c)>1])\n",
    "    num_cc = len(cc)\n",
    "    tree_ratio = np.sum([nx.is_tree(G.subgraph(c))for c in cc])/num_cc\n",
    "\n",
    "    return num_cc, tree_ratio\n",
    "\n",
    "def analytics(data):\n",
    "    data2 = deepcopy(data)\n",
    "    data2.edge_index = torch.tensor([[data2.edge_index[0][i], data2.edge_index[1][i]] for i in range(data2.num_edges) if data2.edge_weight[i] == 1]).T\n",
    "    G = to_networkx(data2, to_undirected=True, node_attrs=['pos'], edge_attrs=['edge_weight'])\n",
    "\n",
    "    return *cc_and_trees(G), num_squares(G)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [],
   "source": [
    "G = nx.grid_2d_graph(width, height)\n",
    "nx.set_edge_attributes(G, {e:{\"edge_weight\":1.} for e in G.edges(data=False)})\n",
    "nx.set_node_attributes(G, {n:{'pos':n} for n in G.nodes(data=False)})\n",
    "data = from_networkx(G)\n",
    "data.batch = torch.zeros(data.num_nodes).long()\n",
    "data.edge_index, data.edge_weight = torch_geometric.utils.coalesce(edge_index=data.edge_index, edge_attr=data.edge_weight)\n",
    "data.edge_state = torch.hstack((data.edge_weight.unsqueeze(1), 1. - data.edge_weight.unsqueeze(1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = data.to(device)\n",
    "model.to(device)\n",
    "model.eval()\n",
    "timesteps = torch.tensor([num_timesteps-1]).to(device)\n",
    "noise = model.add_noise(G_start=data, graph_timesteps=timesteps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial graph\n",
      "Number of connected component: 1\n",
      "Ratio of trees: 0.0\n",
      "Number of squares: 961\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Noise\n",
      "Number of connected component: 90\n",
      "Ratio of trees: 0.7777777777777778\n",
      "Number of squares: 39\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/sAAAP7CAYAAAAEeJ46AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABer0lEQVR4nO3dP24c1/I/7JIw2SRDYDISAsTMmZUqkGOG3oW0AmkH5g7sXThk7sCpnCkTAYHMCIySyQjMG/hL6qc/w2u9mO46qnqejBP401XnnO6u0SXvo91utwsAAACgjMfZFwAAAAAclmEfAAAAijHsAwAAQDGGfQAAACjGsA8AAADFGPYBAACgGMM+AAAAFGPYBwAAgGIM+wAAAFCMYR8AAACKMewDAABAMYZ9AAAAKMawDwAAAMUY9gEAAKAYwz4AAAAUY9gHAACAYgz7AAAAUIxhHwAAAIox7AMAAEAxhn0AAAAoxrAPAAAAxRj2AQAAoBjDPgAAABRj2AcAAIBiDPsAAABQjGEfAAAAijHsAwAAQDGGfQAAACjGsA8AAADFGPYBAACgGMM+AAAAFGPYBwAAgGIM+wAAAFCMYR8AAACKMewDAABAMYvsC3jI2w+buLzZxtP1Mp49Ocq+nFlk1ZzZ647r3E23Ne5Wb6aO9y658+lWs17Xz83Mlltfx16Pvs7DDvvnF+/ij7/e3//88sVpvDn7KfGKppdVc2avO65zN93WuFu9mTreu+Ra42q5mdndcjOz5dZ/F+jY6x9hnR/tdrtd9kV86e2HTfz6+99fff7nq+dDfmNyCPtqvr14HnEzYc3rTSzOcnrdcZ276bbG3erNlHbPjNh736x6vx7t+WSND895+iSr15nvXWXP8mC5ld8Fsvb1iPeu0dZ5yH/Zv7zZ7v18pOYd0r6aP95uY3s9Xc3L1TbWe65n6l53XOduuq1xt3ozZd0zI/bfN6ver0d7Plnjw3OePsnqdeZ7V9WzPFpu5XeBrH094r1rtHUecth/ul5+1+cV7KtttVjG6njC4EVerzuuczfd1rhbvZnS7pkRe++bVe/Xoz2frPHhOU+fZPU6872r7FkeLLfyu0DWvh7x3jXaOg857D97chQvX5x+9jsQr345HepbkkPbV/Pr36au+SjOL3J63XGdu+m2xt3qzZR3z4zYd9+ser8e7flkjQ/PefqUm9XrzPeuumd5rNzK7wJZ+3rEe9do6zzk7+zfOfl5Ex9vt7FaLOPqn7EaN5WsmjP/kmTHde6m2xp3qzdTZq+7/dXhbrkRefur47tAt/3V8d7VbV93fBfotsbZ2f/F2MP+ScT1dcTxccTVVfbVzEPN2VfDFLqtcbd6M+k1U8raX/Z1fR3XuFvN3eqN6Fnz6B5nXwAAAABwWIZ9AAAAKMawDwAAAMUY9gEAAKAYwz4AAAAUY9gHAACAYgz7AAAAUIxhHwAAAIox7AMAAEAxhn0AAAAoxrAPAAAAxRj2AQAAoBjDPgAAABRj2AcAAIBiDPsAAABQjGEfAAAAijHsAwAAQDGGfQAAACjGsA8AAADFGPYBAACgGMM+AAAAFGPYBwAAgGIM+wAAAFDMIvsCHrTexHK1jVgsI+Jo1ui3HzZxebONp+tlPHsyY3ZSzWn1RrSruVtuRLRb4473Lr2u3+tuuRGRt78S93U37l31a+5Wb6pua5yc/V8MO+yfX7yLxdn7WN//fBpvzn6aLfuPv97f//zyxTzZWTVn1XuX3anmbrl32d3WuOO9S6/r97pT7l121r0ra193495Vv+Zu9WbqtsbZ2f/Vo91ut8u+iC+9/bCJX3//+6vPby+eR9xM/I3JehOLs6+z/3z1fNJva9JqTqo3ol/N++otu7cihut11t7S6wm4d8md0mA1z7GvuxntHHe8d3k+1TFaryu/d32vIf9l//Jm+83PP95uY3s9bfOWq+39N1JfXtOUC5dVc1a9dxnfUrXmffVW3VsR4/U6a2/p9eG5d8md0mg1z7GvuxntHHe8d3k+1TFaryu/d32vIYf9p+vlNz9fLZaxOp44fPHt7H3XdChpNSfV+1BG1Zr3/ffL7q2I4Xqdtbf0egLuXXKnNFjNc+zrbkY7xx3vXZ5PdYzW68rvXd9ryGH/2ZOjePni9LPfgXj1y2m8/m2Ob0mO4vzi6+ypv6HJqzmn3oh+Ne+rt+7eihit11l7S6+n4N4lt2J23r7uZrRz3PHe5flUx2i9rvze9b2G/J39O5l/3fDk5018vN3GarGMq3/q/zXJrHozs7v1uuN56pabmd3xL7V321/dciP6PSc66rjG3Wrulpup47vA6H+Nf+hhP9PJScT1dcTxccTVVfbVTC+zXr2uL6vmbrnZ2d1021/dcjN1rLmbjmvc7R7ScY0Zz+PsCwAAAAAOy7APAAAAxRj2AQAAoBjDPgAAABRj2AcAAIBiDPsAAABQjGEfAAAAijHsAwAAQDGGfQAAACjGsA8AAADFGPYBAACgGMM+AAAAFGPYBwAAgGIM+wAAAFCMYR8AAACKMewDAABAMYZ9AAAAKMawDwAAAMUY9gEAAKAYwz4AAAAUY9gHAACAYgz7AAAAUMwi+wIe8vbDJi5vtvF0vYxnT47mDV9vYrnaRiyWETFfdlrNSfVmZrfsdZasmrvlJmZnnaeOzwm58/GcmE+7e0jDNW53D2l47+qW+yMYdtg/v3gXf/z1/v7nly9O483ZT7NlL87ex/r+53mys2rOqjczu2Ovs2SucafczOzM89TxOSF3vjX2nJhHt3tI1zXudA/peu/qlPujeLTb7XbZF/Gltx828evvf3/1+e3F84ibib+tWW9icZaQ3S03M3tP7p+vnk/6beC+fT11bqasmkfL7Xieqp7jiPH2V7fcjuep43Oiaq+9C3zi+XR4ev2vyufpew35L/uXN9tvfv7xdhvb62kXbrna3n8LN2d2t9zM7H25lzfbSW8M+/b11LmZsmoeLbfjeap6ju8y9n3eaV87T/PldnxOVO21d4FPPJ8OT6//Vfk8fa8hh/2n6+U3P18tlrE6njh8kZTdLTcze0/uvn13KPv++1PnZsqqebTcjuep6jl+KKPbvnae5svt+Jyo2mvvAp94Ph2eXv+r8nn6XkMO+8+eHMXLF6ef/f7Fq19O4/Vvc3xDcxTnFxnZ3XIzs7+dO/U3gPv2deVvHrNqHi2343mqeo4jxttf3XI7nqeOz4mqvfYu8C/Pp2nodf3z9L2G/J39O5l/WfHk5018vN3GarGMq3/my87Kzex1t7/cmbXGmazxfLr12r2rfm7meer4TM7SbX91XGPv1vNxnrgz9LCf6eQk4vo64vg44uqqfi7zscb1WWM4nMzz5CzXZ43n4926Pr0ez+PsCwAAAAAOy7APAAAAxRj2AQAAoBjDPgAAABRj2AcAAIBiDPsAAABQjGEfAAAAijHsAwAAQDGGfQAAACjGsA8AAADFGPYBAACgGMM+AAAAFGPYBwAAgGIM+wAAAFCMYR8AAACKMewDAABAMYZ9AAAAKMawDwAAAMUY9gEAAKAYwz4AAAAUY9gHAACAYgz7AAAAUMwi+wIe8vbDJi5vtvF0vYxnT47mDV9vYrnaRiyWETFjdlJuZq+zstNqztpbiaxxfe3WODG7W27qeWp4lttp+N6Vxrt1fXo9nGGH/fOLd/HHX+/vf3754jTenP00W/bi7H2s73+eJzszN7PXGdmZuRlrnMkaW+NquZnZHXOzzlPHs9xNx/euLN6trfGUud16/T0e7Xa7XfZFfOnth038+vvfX31+e/E84mbib2vWm1icJWQPlvvnq+eTfzOWts4Ne51ltDWeutf76rXGE8g6x5nZcufJfSC78lnuJut+7TnxiXeBOpyncQ35L/uXN9tvfv7xdhvb62kXbrna3n8jNWf2aLmXN9vJD0nWOnfsdZbR1njqXu+r1xofXtY5zsyWO0/uQ9mVz3I3Wfdrz4lPvAvU4TyNa8hh/+l6+c3PV4tlrI4nDl8kZQ+Wu28NDiltnRv2Ostoazx1r/f9963xBLLOcWa23HlyH8iufJa7ybpfe0584l2gDudpXEMO+8+eHMXLF6ef/f7Fq19O4/Vvc3xDcxTnFxnZY+XO8W1Y3jr363WW0dZ46l7vq9caTyHrHGdmy81e48pnuZus+7XnxL+8C9TiPI1ryN/Zv5P5lxVPft7Ex9ttrBbLuPpnvuys3I69zqo5q95M3f56uDWuv8aZ2e6Z8+l4lrvpuK+zdHu37rjGztN4hh72M52cRFxfRxwfR1xd1c/N1K3mbvV2ZI2ZUrf9lVlvt14zn457q9u7dcc1zqLX+z3OvgAAAADgsAz7AAAAUIxhHwAAAIox7AMAAEAxhn0AAAAoxrAPAAAAxRj2AQAAoBjDPgAAABRj2AcAAIBiDPsAAABQjGEfAAAAijHsAwAAQDGGfQAAACjGsA8AAADFGPYBAACgGMM+AAAAFGPYBwAAgGIM+wAAAFCMYR8AAACKMewDAABAMYZ9AAAAKMawDwAAAMUY9gEAAKCYRfYFPOTth01c3mzj6XoZz54czRu+3sRytY1YLCNixuys3ExJNaftr4ZrnNVrazyfdmucmd1tf2XW263XDXU8x+1q7pYbDZ/J7tV7DTvsn1+8iz/+en//88sXp/Hm7KfZshdn72N9//M82Vm5mTJ7nbG/uq5xVq+t8Ty6rXFmdrf9lVlvt1531PEcd6u5W+5ddqdnsnv1wx7tdrtd9kV86e2HTfz6+99ffX578TziZuJva9abWJwlZO/J/fPV8/n/Vw0z2bfOU9fcLTdT2ll2jmfTbo0fyHYPOazMerv1uqOO7wLdah4tt+Mc470r35D/sn95s/3m5x9vt7G9nnbhlqvt/TdDc2bvy7282ZbdrPvWeeqau+VmyjrLzvF8uq3xQ9nuIYeVWW+3XnfU8V2gW82j5XacY7x35Rty2H+6Xn7z89ViGavjicMXSdl7cvf1ooJ9tU1dc7fcTGln2TmeTbs1fiDbPeSwMuvt1uuOOr4LdKt5tNyOc4z3rnxDDvvPnhzFyxenn/3ex6tfTuP1b3N8Q3MU5xcZ2d/Orfyt1L51nrrmbrmZ8s6yczyXfmu8P9s95LAy6+3W6446vgt0q3m03I5zjPeufEP+zv6dk5838fF2G6vFMq7+mXfRsrJT/x8IkmT12hrPxxrXl1Vz5nOi3V87TpJZb+b+Yh4dnxOeybVzM7M7vguMbuxh/yTi+jri+Dji6qpPdjdZvbbG87HGTMUaMyX7q76Oa+yZTDX21n6Psy8AAAAAOCzDPgAAABRj2AcAAIBiDPsAAABQjGEfAAAAijHsAwAAQDGGfQAAACjGsA8AAADFGPYBAACgGMM+AAAAFGPYBwAAgGIM+wAAAFCMYR8AAACKMewDAABAMYZ9AAAAKMawDwAAAMUY9gEAAKAYwz4AAAAUY9gHAACAYgz7AAAAUIxhHwAAAIox7AMAAEAxi+wLeNB6E8vVNmKxjIijPtkJ3n7YxOXNNp6ul/HsSZNeJ+Wm9jqLNW6RnSLxXp3Va7kzavYukCltnRs+JzyTa+dmZnc7xxHjv3cNO+yfX7yLxdn7WN//fBpvzn4qn53h/OJd/PHX+/ufX76o3+vM3KxeZ7HG856nTvsr+zmR0Wu59Z9PHWXur47PCc/kurmZ2d3O8V326O9dj3a73S77Ir709sMmfv39768+//PV88m/McnMztCx1/tyby+eR9xMWPN6E4uzPnsrYrxeV15j965/Zfa66v7qVm9Ev/OUabR3gaq5D2V7Jh9WWp8jhqtZr/MN+S/7lzfbvZ9P3bzM7Awde70v9+PtNrbX0+UuV9v7bx2/vJ6KeytivF5XXmP3rk+fZ/W66v7qVu9dxr7PK56nTKO9C1TNfSjbM/mwsvocMV7Nep1vyGH/6Xr5XZ9Xyc7Qsdf7/vurxTJWxxMGL3rtrYjxel15jd27Hv58juyq+6tbvQ9lVD1PmUZ7F6ia+1CGZ/JhpfU5Yria9TrfkMP+sydH8fLF6We/A/Hql9NZviXJzM7Qsdf7cl//NnXNR3F+0WdvRYzX68pr7N6V3+uq+6tbvRH9zlOm0d4FquY+lO2ZfFh5fY4YrWa9zjfk7+zf6fhXLLOc/LyJj7fbWC2WcfVPj15n5Wb2Oku3Nc68f3TbXx173S3Xu0AP3fZX5r262z2k297KzO62xtnZ/8XQwz7zOTmJuL6OOD6OuLrKvpra9Jop2V/zyep1t1x66La/Muvtdg/ptrcydVzj0ffX4+wLAAAAAA7LsA8AAADFGPYBAACgGMM+AAAAFGPYBwAAgGIM+wAAAFCMYR8AAACKMewDAABAMYZ9AAAAKMawDwAAAMUY9gEAAKAYwz4AAAAUY9gHAACAYgz7AAAAUIxhHwAAAIox7AMAAEAxhn0AAAAoxrAPAAAAxRj2AQAAoBjDPgAAABRj2AcAAIBiDPsAAABQzCL7AhjEehPL1TZisYyIo1mj337YxOXNNp6ul/HsybzZKRJ7nSVrjbvlRkTa/mp3jiPyznKz3My91e0e4t5V/zylZnfL7ajjGg++vwz7xPnFu1icvY/1/c+n8ebsp9my//jr/f3PL1/Ml50hs9dZsta4W+5ddsb+6naOI3J73S038zx1uodk97rT/sp+7+p2D+n23pWl4xr/CPvr0W6322VfBHneftjEr7///dXntxfPI24m/nZqvYnF2dfZf756XvJfBvf1umq9EXk1d8t9KHvys9zsHEf06/Vo5ynz+ZS1xmVzM7O75WZmN7t3ddTtuRjx4+wv/7Lf3OXN9puff7zdxvZ62o26XG3vvwn78ppGOiSHsq/XVeuNyKu5W+5D2VOf5W7nOKJfr0c7T5nPp6w1rpqbmd0tNzO7272ro27PxbuMfZ+PtL8M+809XS+/+flqsYzV8cThi29n77umH92+uqrWG5FXc7fchzImP8vNznFEv16Pdp4yn09Za1w2NzO7W25mdrN7V0fdnosPZYy2vwz7zT17chQvX5x+9jtrr345jde/zfGN1FGcX3ydPdK3YYe0r9dV643Iq7lb7kPZ05/lXuc4ol+vRztPmc+nrDWum5uZ3S03M7vXvaujbs/FiB9nf/mdfSKi5187znLy8yY+3m5jtVjG1T/1643Iq7lbbmZ2x33d7S+mZ61xx+eTXtfvdcfnRLc17qjjGo++vwz7MLOTk4jr64jj44irq+yrmUdWzd1yM7M77uturPF89Ho+He+Z3fZXt3o7cp72e5x9AQAAAMBhGfYBAACgGMM+AAAAFGPYBwAAgGIM+wAAAFCMYR8AAACKMewDAABAMYZ9AAAAKMawDwAAAMUY9gEAAKAYwz4AAAAUY9gHAACAYgz7AAAAUIxhHwAAAIox7AMAAEAxhn0AAAAoxrAPAAAAxRj2AQAAoBjDPgAAABRj2AcAAIBiDPsAAABQjGEfAAAAillkX8BD3n7YxOXNNp6ul/HsyVH25cwiq+bMXrereb2J5WobsVhGRIN6I9Jqbpebmd1wX7t3zaPjGqfeQ5K063XD50S3Ne547+q2xunZ/8Gww/75xbv446/39z+/fHEab85+Sryi6WXVnNnrbjWfX7yLxdn7WN//XLveu+ysmjvlZmZ33dfuXXXrzczOvIdk6dbrrs+Jbmvc8d7VaY2zs/+rR7vdbpd9EV96+2ETv/7+91ef//nqedl/4d9X8+3F84ibCWteb2JxlpD7QPbU69yu10l9jhiv12X3VkS7/TVir8vWPNje6rjG3n8mMNi+znwmd7t3la03ol/NDZ8T32vIf9m/vNnu/Xyk5h3Svpo/3m5jez1dzcvV9v7bqDlzH8qeep279Tqrz3cZ31K15qx6I/rtrxF7XbXm0fZWxzX2/nN4o+3rzGdyt3tX1Xoj+tXc8TnxvYYc9p+ul9/1eQX7alstlrE6njB4kZT7QPbU69yu10l9fiijas1p9Ua0218j9rpszYPtrY5r7P1nAoPt68xncrd7V9l6I/rV3PA58b2GHPafPTmKly9OP/u9j1e/nA71Lcmh7av59W9T13wU5xcZufuzp17nfr3O6XPEeL2uu7ciuu2vEXtdt+ax9lbHNfb+M4Wx9nXmM7nbvatuvRH9au73nPheQ/7O/p2Tnzfx8XYbq8Uyrv4Zq3FTyao58y+GZtUsdz5Z+6tjr7vV3LHX3c5Tx+eT/zci+7pittz5dKu547vAfzX2sH8ScX0dcXwccXWVfTXzULPcarmZOva6W80de52lW70RPWvuxhrDj8+7wH6Psy8AAAAAOCzDPgAAABRj2AcAAIBiDPsAAABQjGEfAAAAijHsAwAAQDGGfQAAACjGsA8AAADFGPYBAACgGMM+AAAAFGPYBwAAgGIM+wAAAFCMYR8AAACKMewDAABAMYZ9AAAAKMawDwAAAMUY9gEAAKAYwz4AAAAUY9gHAACAYgz7AAAAUIxhHwAAAIox7AMAAEAxhn0AAAAoZpF9AQ9ab2K52kYslhFxNGv02w+buLzZxtP1Mp49mTE7qea0eiPy1lnubLqdp8xet6u5Ya+7naeOz6esmjN7bV/Pp9v+6pabnZ2i4bvAfzXssH9+8S4WZ+9jff/zabw5+2m27D/+en//88sX82Rn1ZxV7112Vs1ynadKuZnZ3XIzszuep47Pp6w1zuy1fV2/13Jrr3GWju8C3+PRbrfbZV/El95+2MSvv//91ed/vno++bdTWdn7cm8vnkfcTFjzehOLs4TczOw9ud3WuON5qpqbmW1ff1K15tHq7fh8qrq3Ity7Zst9ILtbr8vWG5F6ljN0fO/6XkP+y/7lzXbv51M3Lyt7X+7H221sr6fLXa62999GzZmbmb0vt9sadzxPVXMzs+3rT6rWPFq9HZ9PVffWXca+z+3rebK79bpqvRG5ZzlDx/eu7zXksP90vfyuzytk7/vvrxbLWB1PGLxIys3M3pPbbY07nqequZnZ9vUnVWserd6Oz6eqe+uhDPt6vuxuvS5bb0TqWc7Q8b3rew057D97chQvX5x+9vsmr345neVbkqzsfbmvf5u65qM4v8jIzcz+dm63Ne54nqrmZmbb15+yq9Y8Wr0dn09V91aEe9d8ufuzu/W6br0RmWc5Q8f3ru815O/s38n8S5InP2/i4+02VotlXP0zX3a33MzsrP3Vrd6IfjU7Tz163a1mf9G6fs0d713dzlNmdrc17niesnR8F/ivhh72M52cRFxfRxwfR1xdya2anaFbvRH9anae5tOt3oieNTOPjvcu52k+3da443nK0q3e7/E4+wIAAACAwzLsAwAAQDGGfQAAACjGsA8AAADFGPYBAACgGMM+AAAAFGPYBwAAgGIM+wAAAFCMYR8AAACKMewDAABAMYZ9AAAAKMawDwAAAMUY9gEAAKAYwz4AAAAUY9gHAACAYgz7AAAAUIxhHwAAAIox7AMAAEAxhn0AAAAoxrAPAAAAxRj2AQAAoBjDPgAAABSzyL6Ah7z9sInLm208XS/j2ZOjecPXm1iuthGLZUTMmN0tNzs7Q1K9Hc9TWs0Nz1PHXnerOfUekqRdzQ3vXc7TjJqtccfz1O25+CMYdtg/v3gXf/z1/v7nly9O483ZT7NlL87ex/r+53myu+VmZ2fIXOOO5ymj5o7nqWuvO9WceQ/J0q3m7PPU6f2n296K6LnGHc9Tp+fij+LRbrfbZV/El95+2MSvv//91ee3F88jbib+tma9icVZQvZguX++ej75N3L71nmO7AxZ9TpPDXIzs7vlZmYPllv1Xh3h+XSn8rtA2rPRebqXtcZl91ZE2v5ynsY15L/sX95sv/n5x9ttbK+nXbjlanv/zdCc2aPlXt5sJz8k+9Z5juwMWfU6T/VzM7O75WZmj5Zb9V4d4fn0/35e9V0g69noPH3+ecYaV91bEXn7y3ka15DD/tP18pufrxbLWB1PHL5Iyh4sd98aHNK+jDmyM2TV6zw1yM3M7pabmT1YbtV7dYTn0//6vEJ22rPRefqfn1fNzXw+la254Xn6XkMO+8+eHMXLF6ef/d7Hq19O4/Vvc3xDcxTnFxnZY+XO8W3YvnWu+k1cVr3OU4fczOxuuZnZY+VWvVdHeD5F1H8XyHs2Ok8RuWtcd29FZO0v52lcQ/7O/p3Mv1SalZ2Ve/LzJj7ebmO1WMbVPz16naXb3srM7pYbkXeWu+VG9Ntf3e7VEbn7K0PHe5fzNJ9uvfZ86tHr0Q097DOfk5OI6+uI4+OIq6vsqwH+/8o6y91y6cH+mo9eU409PR+93u9x9gUAAAAAh2XYBwAAgGIM+wAAAFCMYR8AAACKMewDAABAMYZ9AAAAKMawDwAAAMUY9gEAAKAYwz4AAAAUY9gHAACAYgz7AAAAUIxhHwAAAIox7AMAAEAxhn0AAAAoxrAPAAAAxRj2AQAAoBjDPgAAABRj2AcAAIBiDPsAAABQjGEfAAAAijHsAwAAQDGGfQAAAChmkX0BD3n7YROXN9t4ul7GsydHLbLTal5vYrnaRiyWEaHXFTlP9XMjIu8sd8uNpvurm6T91XJv6XV57Xrt+TRbbsde/1fDDvvnF+/ij7/e3//88sVpvDn7qXR2Zu7i7H2s73/W62qcp/q5d9kZZ7lb7l12t/3VTea+7ra39Lr+Oe7Wa88nvR7Fo91ut8u+iC+9/bCJX3//+6vP/3z1fPJvTLKyR8u9vXgecTPxt1PrTSzOErL35M6xvzJY4086nqeyNSee4441dzPaGlfeW+3efxqe42699i6Qn1u5199ryH/Zv7zZ7v186uZlZY+W+/F2G9vraXu9XG3vv4WbM3tf7hz7K4M1/qTjeapac+Y57lhzN6OtceW91e39p+M57tZr7wL5uZV7/b2GHPafrpff9XmF7NFyV4tlrI4njf6/36tJyN6TO8f+ymCNP+l4nsrWnHiOO9bczWhrXHlvtXv/aXiOu/Xau0B+buVef68hh/1nT47i5YvTz34H4tUvp7N8S5KVPVru69/m+EbqKM4vMrK/nTvSt3CHZI0/5XY8T3VrzjvHHWvuZrQ1rry3+r3/9DvH3XrtXSA/t3Kvv9eQv7N/5+TnTXy83cZqsYyrf+ZtXFZ2Vq6/1D7WwZyCNa5/jjOzO967OtbcTbd7iHuXczylbr3u+N7VbY2zs/+LsYf9k4jr64jj44irqx7ZmTUDh+HeNV9upo41M4+O57hjzd3odX3WeDyPsy8AAAAAOCzDPgAAABRj2AcAAIBiDPsAAABQjGEfAAAAijHsAwAAQDGGfQAAACjGsA8AAADFGPYBAACgGMM+AAAAFGPYBwAAgGIM+wAAAFCMYR8AAACKMewDAABAMYZ9AAAAKMawDwAAAMUY9gEAAKAYwz4AAAAUY9gHAACAYgz7AAAAUIxhHwAAAIox7AMAAEAxhn0AAAAoZpF9AQ9ab2K52kYslhFx1CM7Kffth01c3mzj6XoZz57M3OskWTV3y83OTuHeNVts6t5qVnO33NTsZuc4NTuz5m7cM+trtsbZ2f/FsMP++cW7WJy9j/X9z6fx5uyn0tmZuX/89f7+55cv5ut1lqyau+VmZ2dw7+px7+pWc7fczOxu5zgzO7Pmbtwz6++tbmucnf1fPdrtdrvsi/jS2w+b+PX3v7/6/PbiecTNxN+YrDexOEvIHiz3z1fPh/x26hDS9lfDNd7X66r7a8R719S9Hu08Ze7rqjWPVm/H81R2jSNaPhu7GW1fV83NNFqvKz8nvteQ/7J/ebP95ucfb7exvZ62ecvV9v4bqTmzR8u9vNkOtVEPKWt/dVzjfb2uur9GvHdN3evRzlPmvq5a82j1djxPVdc4ouezsZvR9nXV3Eyj9bryc+J7DTnsP10vv/n5arGM1fHE4Yuk7MFy961BBWn7q+Ea78uour9GvHdN3evRzlPmvq5a82j1djxPZdc4ouWzsZvR9nXV3Eyj9bryc+J7DTnsP3tyFC9fnH72OxCvfjmN17/N8S3JUZxfZGSPlTvSN1KHlre/+q3xvl5X3V8j3rum7vVo5ylzX1etebR6O56numsc0fHZ2M1o+7pqbqbRel35OfG9hvyd/TsnP2/i4+02VotlXP3T4y8rZtU8+l+SnEK3Xmeep8zsDJnnKavX3XIj+v2F545r3K1m56n+8ymTe1d93dY4Yvx7yNjD/knE9XXE8XHE1VX21cyjY81ZuvU6s95uvc6U1etuuR11XONuNTtPVOQ81afX+z3OvgAAAADgsAz7AAAAUIxhHwAAAIox7AMAAEAxhn0AAAAoxrAPAAAAxRj2AQAAoBjDPgAAABRj2AcAAIBiDPsAAABQjGEfAAAAijHsAwAAQDGGfQAAACjGsA8AAADFGPYBAACgGMM+AAAAFGPYBwAAgGIM+wAAAFCMYR8AAACKMewDAABAMYZ9AAAAKMawDwAAAMUssi/gQetNLFfbiMUyIo5mjX77YROXN9t4ul7GsyczZifWnKVbr7vVm5md1eu0NY7IW+duuYna3UMa3rva5UbyfZNZuHfNp937T8N3gf9q2GH//OJdLM7ex/r+59N4c/bTbNl//PX+/ueXL+bJzqw5S7ded6s3Mzuz1xm5d9lZve6Um6nbPaTrvatT7l121n2Tebh31T9P3db4R/Fot9vtsi/iS28/bOLX3//+6vPbi+cRNxN/W7PexOLs6+w/Xz2f9BuqfTVPnZspbZ2brXHm3rLG8+RmZndb40zW+F/O0wQa9pr5OE//8t51eO4f/9uQ/7J/ebP95ucfb7exvZ524Zar7f03Q19e05SbZl/NU+dmylrnbmucubes8Ty5mdnd1jiTNf50Pc7TYXXsNfNxnj5dj/euw3L/+N+GHPafrpff/Hy1WMbqeOLwxbez913Toez770+dmyltnZutcebessbz5GZmd1vjTNb44es5JL1++HoOqeP7TzfO08PXc0jdanb/+N+GHPafPTmKly9OP/u9j1e/nMbr3+b4huYozi++zp7626F9NVf+VipvnXutcebessb5vc6queoaZ7LGztN0+vWa+ThP+eepas3uH//bkL+zfyfzL7NmZZ/8vImPt9tYLZZx9U+Pjdqt191yI/r9VdjMXnfbXx3/gne3Xrt31c+N6Pn+041713y63UPcP/Ybetjv6OQk4vo64vg44uoq+2pqy+p1t9yOMnttf9XXrdfd6u3KOtfXbY271ZtJr/d7nH0BAAAAwGEZ9gEAAKAYwz4AAAAUY9gHAACAYgz7AAAAUIxhHwAAAIox7AMAAEAxhn0AAAAoxrAPAAAAxRj2AQAAoBjDPgAAABRj2AcAAIBiDPsAAABQjGEfAAAAijHsAwAAQDGGfQAAACjGsA8AAADFGPYBAACgGMM+AAAAFGPYBwAAgGIM+wAAAFCMYR8AAACKWWRfwEPeftjE5c02nq6X8ezJUY/s9SaWq23EYhkR89acpV2vu+VG7llOkXmOm+0vzwnnaUpZa9zunhnRbl+7dzU4T832dETPXo9+vx522D+/eBd//PX+/ueXL07jzdlPpbPPL97F4ux9rO9/nq/mLN163S33LjvrLGfI7nWn/eU5Uf85kX2esta40z0zoue+du+qfZ667emInr3+Ee7Xj3a73S77Ir709sMmfv39768+//PV88m/McnKzqw5y76aby+eR9xMWPN6E4uzPmuc1ueItF5n6dhr+/qTqr3O4l1gvtxM3Wq2rz/Jet+r+p6Zqd3eivhh1nnIf9m/vNnu/Xzq5mVlZ9acZV/NH2+3sb2erublanv/7d+X11NxjbP6HJHX6ywde21ff35NFXudxbvAfLmZutVsX3+S9b5X9T0zU7e9FfHjrPOQw/7T9fK7Pq+QnVlzln21rRbLWB1PGLzotcZpfY5I63WWjr22rz+p2uss3gXmy83UrWb7+pOs972q75mZ2u2tiB9mnYcc9p89OYqXL04/+x2IV7+czvItSVZ2Zs1Z9tX8+repaz6K84s+a5zX54isXmfp2Gv7+lN21V5n8S4wX26mbjXb159ys973qr5nZuq3tyJ+lHUe8nf275z8vImPt9tYLZZx9c+8jcvKHv0vOk6hW6+zcjPPU7d93fGvLHfLzczudp46vgtk1pylW80d93W3e2a3e3VEv72Vnf1fjD3sn0RcX0ccH0dcXfXJ7kav56HPwI+o47tAx/t1t5o77mvqs7fG8zj7AgAAAIDDMuwDAABAMYZ9AAAAKMawDwAAAMUY9gEAAKAYwz4AAAAUY9gHAACAYgz7AAAAUIxhHwAAAIox7AMAAEAxhn0AAAAoxrAPAAAAxRj2AQAAoBjDPgAAABRj2AcAAIBiDPsAAABQjGEfAAAAijHsAwAAQDGGfQAAACjGsA8AAADFGPYBAACgGMM+AAAAFGPYBwAAgGIW2RfwoPUmlqttxGIZEUctst9+2MTlzTaerpfx7En93IjQ67kknqduvc48T91qTr13JWlXc8N3gW7PxYjoV3PDfd3u3pWo5b7mm4Yd9s8v3sXi7H2s738+jTdnP5XOPr94F3/89f7+55cvaufeZev1PLmZ56lbrzPPU6eaM3udpVvN2feurOdTp+fiXXanmrvu6073rkwd9zX7Pdrtdrvsi/jS2w+b+PX3v7/6/PbiecTNxN8SrTexOEvI3pP756vnk34jN2Kvy9Y82N6yxhNIqjdivJor9zrLvjWuWrPn0ydlz3Fm9mBr3PE5UfXelSlrf3V7Pv1IhvyX/cub7Tc//3i7je31tBtmudrefyM1Z/a+3Mub7aSHZMReV615tL1ljQ8vq967jG+pur8ye51l3xpXrdnz6ZOq5zgze7Q17vicqHrvypS1v7o9n34kQw77T9fLb36+WixjdTxx+CIpe0/uvl4cyoi9LlvzYHvLGk8gqd6HMsrur8ReZ9lXW9WaPZ8+KXuOM7MHW+OOz4mq965MWfur2/PpRzLksP/syVG8fHH62e+bvPrlNF7/Nsc3Q0dxfpGR/e3cqb8NG7HXdWsea29Z4ynk1BsxXs2Ve51l3xpXrdnz6VNu3XOcmT3WGnd8TlS9d2XK2l/dnk8/kiF/Z/9O5l/tPPl5Ex9vt7FaLOPqn/p/qVSv6+dm9Tkzu2Ov7ev6utXc8d7V7Z6Zmd2x1x1r7sYac2foYT/TyUnE9XXE8XHE1VX21dSm1/PI7HO3Ne5Wb6aOve5Wc8d7V7c1ztSx1x1r7sYac+dx9gUAAAAAh2XYBwAAgGIM+wAAAFCMYR8AAACKMewDAABAMYZ9AAAAKMawDwAAAMUY9gEAAKAYwz4AAAAUY9gHAACAYgz7AAAAUIxhHwAAAIox7AMAAEAxhn0AAAAoxrAPAAAAxRj2AQAAoBjDPgAAABRj2AcAAIBiDPsAAABQjGEfAAAAijHsAwAAQDGGfQAAAChmkX0BD3n7YROXN9t4ul7GsydH84avN7FcbSMWy4iYLzu15ixJvc6StsaZfe52nhJ7nVWzXtevuVu9qdnd1jgzu9k7SET0rDmBOaZ+bnb2fzHssH9+8S7++Ov9/c8vX5zGm7OfZstenL2P9f3P82Rn1pwlq9dZstY4s8/dzlN2r7Nq1uvaNXerNzO72xpnZnd7B4noWXOG7PPU6R6S3evRZ7dHu91ul30RX3r7YRO//v73V5//+er55N+Y7Mu+vXgecTNh9noTi7OcmrNkrnOGrHqdp/zcjr3uuK+zau52nibPzcx2nu5V7XWmbu9dWdL2dMRw95DK5/hHOU9D/sv+5c127+dTN29f9sfbbWyvp8terrb338B9eT0jbZhDylznDFn1Ok/5uR173XFfZ9Xc7TxNnZuZ7Tx9UrXXmbq9d2XJ2tMR491DKp/jH+U8DTnsP10vv+vzObJXi2WsjicMXuTVnCVznTNk1es85ed27HXHfZ1Vc7fzNHluZrbzdK9qrzN1e+/KkranI4a7h1Q+xz/KeRpy2H/25Chevjj97HcgXv1yOsu3JPuyX/82dfZRnF/k1Jwlc50zZNXrPOXndux1x32dVXO38zR9bma283SXXbXXmbq9d2XJ29MRo91DKp/jH+U8Dfk7+3dOft7Ex9ttrBbLuPpn3sZlZY/+Fx2n0K3mjnur219nzex1t/3lOSG3Yrbz1KPmLB1rztDxXaDbczFi/PM09rB/EnF9HXF8HHF11Seb2uwtptRtf3lOwOF0PE8dz3HHmrtxnuYzes2Psy8AAAAAOCzDPgAAABRj2AcAAIBiDPsAAABQjGEfAAAAijHsAwAAQDGGfQAAACjGsA8AAADFGPYBAACgGMM+AAAAFGPYBwAAgGIM+wAAAFCMYR8AAACKMewDAABAMYZ9AAAAKMawDwAAAMUY9gEAAKAYwz4AAAAUY9gHAACAYgz7AAAAUIxhHwAAAIox7AMAAEAxi+wLeNB6E8vVNmKxjIijFtlvP2zi8mYbT9fLePakfm5mdlrNzfZWdnaG1Hq77S/PCbkFs52n+jV7TsidVLPzlGrwmocd9s8v3sXi7H2s738+jTdnP5XOPr94F3/89f7+55cvaudmZmfmdtpb2dkZsnvdaX95TvS4Z3a7dzlP856nTuf4LrtTzd1y77I7nadMP0LNj3a73S77Ir709sMmfv39768+//PV88m/GduXfXvxPOJmwuz1JhZn89es159k9Tqr3slzH8ieY39lSFvjCPv6/3S8d1Xt9YjnSa8n0K3mAe9den1YztN8uZl+lJqH/Jf9y5vt3s+nbt6+7I+329heT5e9XG3vvxX68nqmrFmvP7+ejF5n1Tt17kPZc+yvDFlrHGFf/7/X0+3eVbXXI54nvT68bjWPeO/S68NynubLzfSj1DzksP90vfyuz+fIXi2WsTqeMHiRU7Ne/+/rOZTR6p0894HsOfZXhrQ1jrCv/8f1HNJoNVft9YjnSa8n0K3mAe9den1YztN8uZl+lJqHHPafPTmKly9OP/tdl1e/nM7yLcm+7Ne/TZ19FOcX89es159ys3qdVe/0ufuzR/rG85Dy1jjCvu5776ra6xHPk15PoVvN49279PqwnKf5cjP9KDUP+Tv7d05+3sTH222sFsu4+sdf4J2SXtfvdce/aJ0ls95u+0uv5VbM7ra3MrOzeu29S27F7G7vexG5Z/m/GHvYP4m4vo44Po64usq+mtr0ej56zZTsr/noNVOxt+aT1WtrDDWMfpYfZ18AAAAAcFiGfQAAACjGsA8AAADFGPYBAACgGMM+AAAAFGPYBwAAgGIM+wAAAFCMYR8AAACKMewDAABAMYZ9AAAAKMawDwAAAMUY9gEAAKAYwz4AAAAUY9gHAACAYgz7AAAAUIxhHwAAAIox7AMAAEAxhn0AAAAoxrAPAAAAxRj2AQAAoBjDPgAAABRj2AcAAIBiFtkX8KD1JparbcRiGRFHs0a//bCJy5ttPF0v49mT+bKzcvW6fq/T6k3M7pYbEe32l17Xz83kOTGfbr3OfO9iHh3PU7fciBj+LA877J9fvIvF2ftY3/98Gm/Ofpot+4+/3t///PLFPNmZuXpdu9dZ9WZmd8u9y+60v/S6R6+zeE70eE5k9TrrvYt5dD1PnXLvskc/y492u90u+yK+9PbDJn79/e+vPr+9eB5xM/E3JutNLM4Ssvfk/vnq+aTfUI3Y67I1d6s3wnn6Px17XXWNI8a7h1TudZbR1rjjvSur5qq5zGfE8+TeNYEf5Nk45L/sX95sv/n5x9ttbK+nbd5ytb3/dmbO7H25lzfbSTfMiL2uWnO3eiOcpzsde111je8yvkWv6xhtjTveu7JqrprLfEY8T+5dh/ejPBuHHPafrpff/Hy1WMbqeOLwRVL2ntx9vTiUEXtdtuZu9UY4T/+nY6+rrvFDGXpdx2hr3PHelVVz1VzmM+J5cu+awA/ybBxy2H/25Chevjj97PcvXv1yGq9/m+NbkqM4v8jI/nbu1N8MjdjrujV3qzfCeerb66prHDHePaRyr7OMtsYd711ZNVfNZT4jnif3rin8GM/GIX9n/07Hv2J58vMmPt5uY7VYxtU/Pf6KpV7Xzs3M7pabmd3tHEf0q7njX+PP6nXHNe527+p4nrrp+Hzq9lzMzv4vhh72Ozo5ibi+jjg+jri6yr6a2vQafnwdz3HHmrNk9doaw4/POZ5PZq9HX+fH2RcAAAAAHJZhHwAAAIox7AMAAEAxhn0AAAAoxrAPAAAAxRj2AQAAoBjDPgAAABRj2AcAAIBiDPsAAABQjGEfAAAAijHsAwAAQDGGfQAAACjGsA8AAADFGPYBAACgGMM+AAAAFGPYBwAAgGIM+wAAAFCMYR8AAACKMewDAABAMYZ9AAAAKMawDwAAAMUY9gEAAKAYwz4AAAAUs8i+gIe8/bCJy5ttPF0v49mTox7Z600sV9uIxTIi5svV63lrztBxjbvltpR4jrvdu1qep6z91WyNM7O75WZmd8vt+Hzq2OvR54lhh/3zi3fxx1/v739++eI03pz9VDr7/OJdLM7ex/r+5/ly9Xq+mjN0XeNOuR1lnuNu966O5ymz153WODO7W25mdsfcjs+njr0efZ54tNvtdtkX8aW3Hzbx6+9/f/X5n6+eT/4t0b7s24vnETcTZq83sThrlPtA9tTrnLm/MqTt6Yjh1jjrPFXdW5lGfE7Y14fl3lU/96Fs+3oC3d41rfF82Xp9b7R3viH/Zf/yZrv386mbty/74+02ttfTZS9X2/tvhTrkPpQ99Tpn7q8MWXs6Yrw1zjpPVfdWphGfE/b1Ybl31c99KNu+Prxu75rWeL5svf78mkZ65xty2H+6Xn7X53NkrxbLWB1PGLxolvtA9tTrnLm/MqTt6Yjh1jjrPFXdW5lGfE7Y14fl3lU/96EM+3oC3d41rfF82Xp9b7R3viGH/WdPjuLli9PPfu/j1S+ns3xLsi/79W9TZx/F+UWn3P3ZU69z5v7KkLenI0Zb46zzVHVvZRrxOWFfH5Z7V/3ch7Lt6yl0e9e0xvNl6/Vd9mjvfEP+zv6dk5838fF2G6vFMq7+mbdxWdlZuf4q7FgHcwqZ56nbGnfbW5kye93tft3tuZiZ3W2NM7O75WZmd9vX3q3rr3HE+O98Yw/7JxHX1xHHxxFXVz2yM2umNnsLDqvbmer4XLTG9bO75WZnZ+hWb0fWeL/H2RcAAAAAHJZhHwAAAIox7AMAAEAxhn0AAAAoxrAPAAAAxRj2AQAAoBjDPgAAABRj2AcAAIBiDPsAAABQjGEfAAAAijHsAwAAQDGGfQAAACjGsA8AAADFGPYBAACgGMM+AAAAFGPYBwAAgGIM+wAAAFCMYR8AAACKMewDAABAMYZ9AAAAKMawDwAAAMUY9gEAAKCYRfYFPGi9ieVqG7FYRsRRj+yk3LcfNnF5s42n62U8ezJvr7OyM2tOkXieuq1xx/PUUrf7dbPnYmZ2uzXOzO6Wm5jdbV93fB53W+OI8dd52GH//OJdLM7ex/r+59N4c/ZT6ezM3D/+en//88sX8/Y6Izuz5gzZ56nTGnc8Tx11u193ey5mZndb48zsbrmZ2d32dcfncbc1vssefZ0f7Xa7XfZFfOnth038+vvfX33+56vnk39jsi/79uJ5xM2E2etNLM7mrzmt3oi9NVftdZYR17jsvs7a0w9kV93XmbKeUe32dcPzNNoaZ7536fXh6XVubuXn8Wh7q/J5+l5D/sv+5c127+dTN29f9sfbbWyvp8terrb330h9eT1T1pxVb8T+mqv2OsuIa1x1X2ft6Yeyq+7rTFnPqG77uuN5Gm2NM9+79Prw9Do3t/LzeLS9Vfk8fa8hh/2n6+V3fT5H9mqxjNXxhMGLnJrT6o3YW3PVXmcZcY3L7uusPf1AdtV9nSnrGdVuXzc8T6OtceZ7l14fnl7n5lZ+Ho+2tyqfp+815LD/7MlRvHxx+tnvQLz65XSWb0n2Zb/+bersozi/mL/mvHoj9tVctddZRlzjuvs6a0/vz666rzNlPaP67et+52m0Nc5879Lrw9Pr+mucZbS9Vfk8fa8hf2f/zsnPm/h4u43VYhlX//T4y4rdciPy1nn0v555aB3/Qny33Ozsbrrtr265mdndcjOzu+VmZmfles+cT1avM2fGzOz/Yuxh/yTi+jri+Dji6ir7apiKdQYAYAreM+eT1evMNR59fz3OvgAAAADgsAz7AAAAUIxhHwAAAIox7AMAAEAxhn0AAAAoxrAPAAAAxRj2AQAAoBjDPgAAABRj2AcAAIBiDPsAAABQjGEfAAAAijHsAwAAQDGGfQAAACjGsA8AAADFGPYBAACgGMM+AAAAFGPYBwAAgGIM+wAAAFCMYR8AAACKMewDAABAMYZ9AAAAKMawDwAAAMUssi/gQetNLFfbiMUyIo5mjX77YROXN9t4ul7GsyfzZmdIrTdpnbutcaasXnfLzczueJ669bpbbmZ2t9xMHXvdrubEeSJLu15nrvHg+2vYYf/84l0szt7H+v7n03hz9tNs2X/89f7+55cv5svOkFlv1jp3W+NMWb3ulpuZ3fE8det1t9zM7G65mTr2ulvNmfNElm69zp4ZR99fj3a73S77Ir709sMmfv39768+v714HnEz8Tcm600szr7O/vPV85Lfco/Y68mzm61xprT9lbTGztMnlc/TaPu66hrv6/Mce8sa/8s5nkDWGmdmN7yHZGm3rwc8T6PtryH/Zf/yZvvNzz/ebmN7PW3zlqvt/bczX17TSAt3KCP2eursbmucKWt/Za2x8/RJ5fM02r6uusb7+jzH3rLG/3KODy9rjTOzO95DsnTb1yOep9H215DD/tP18pufrxbLWB1PHL74dva+a/rRjdjrybObrXGmtP2VtMbO0yeVz9No+7rqGu/778+xt6zxv5zjCWStcWZ2w3tIlnb7esDzNNr+GnLYf/bkKF6+OP3s901e/XIar3+b41uSozi/+Dp7pG9oDmnEXk+f3WuNM+Xtr5w1dp4+5VY+T6Pt66prvK/Pc+wta+wcTydrjTOz+91DsvTb1+Odp9H215C/s3/n5OdNfLzdxmqxjKt/5m1cZnaGjr3u+FeHs2T1uuPeavdXlhNl7a9u+7rj86lbbib72j2kom69zlzj0d9/xh72TyKuryOOjyOurvpkZ9BrKrK3mFLW/uq2rzs+n7rldtRxX2fpVm8m967xPM6+AAAAAOCwDPsAAABQjGEfAAAAijHsAwAAQDGGfQAAACjGsA8AAADFGPYBAACgGMM+AAAAFGPYBwAAgGIM+wAAAFCMYR8AAACKMewDAABAMYZ9AAAAKMawDwAAAMUY9gEAAKAYwz4AAAAUY9gHAACAYgz7AAAAUIxhHwAAAIox7AMAAEAxhn0AAAAoxrAPAAAAxRj2AQAAoJhF9gU8aL2J5WobsVhGxFGL7LcfNnF5s42n62U8ezJjzXo9W25H3fZ15t7Kyu6WGxF5981u+7rh86ldbjR8Jjfc193uIR3fBdy7xrt3DTvsn1+8i8XZ+1jf/3wab85+Kp19fvEu/vjr/f3PL1/Ml6vX89XcTbd9nbm3MnvdKfcuO2t/ddrXXZ9PnXLvsjs9k7N77R5St97MbPeuMe9dj3a73S77Ir709sMmfv39768+v714HnEz8Tcm600szhKyB8v989Xzyb+d2rfOU2dn5XY02hp3PE9Va848x/b1v8rWG9Gv5qx3kAeyqz6TR7x3ld1fg53jjs+nsvfMiB/m3jXkv+xf3my/+fnH221sr6dt3nK1vf9maM7s0XIvb7aTb9R96zx1dlZuR6OtccfzVLXmzHNsX3+6nor1RvSrOesd5KHsqs/kEe9dVffXaOe44/Op6j0z4se5dw057D9dL7/5+WqxjNXxxOGLpOzBcvetwSHty5g6Oyu3o9HWuON5qlpz5jm2rx++nkMZ8V2gbM1Z7yAPZFd9Jo947yq7vwY7xx2fT2XvmRE/zL1ryGH/2ZOjePni9LPfgXj1y2m8/m2Ob0mO4vwiI3us3Dm+kdq3zlNnZ+V2NNoadzxPVWvOPMf2dfV6I/rVnPUOsj+76jN5xHtX3f011jnu+Hyqe8+M+FHuXUP+zv6dzL9uePLzJj7ebmO1WMbVP/Nld8uNyFvnzJq76bav3bvq50b0+38g6LjG3Wpu+dfDk3R8Trhnzscaz2f0eWLoYT/TyUnE9XXE8XHE1ZXcijrWnMW+nk+3Xndc4ywd17hjzdRnf82j472ro9F7/Tj7AgAAAIDDMuwDAABAMYZ9AAAAKMawDwAAAMUY9gEAAKAYwz4AAAAUY9gHAACAYgz7AAAAUIxhHwAAAIox7AMAAEAxhn0AAAAoxrAPAAAAxRj2AQAAoBjDPgAAABRj2AcAAIBiDPsAAABQjGEfAAAAijHsAwAAQDGGfQAAACjGsA8AAADFGPYBAACgGMM+AAAAFLPIvoBhrTexXG0jFsuIOJI7obcfNnF5s42n62U8e1K/5qx60/oc0W5f63WD3Gh4lhuucbeaM+9d3c5Tx+dEu143vHe1W+OI3HX+Dwz733B+8S4WZ+9jff/zabw5+0nuRNl//PX+/ueXL2rXnFlvRu5ddqd9rdf1c++yO53lrmvcqebse1e389TxOdGp113vXZ3W+C47a53/q0e73W6XfREjefthE7/+/vdXn99ePI+4mfDbmvUmFmfj5P756vnk34zpdW5uxzWeuua0eiOG219V1zhivH3dLTdzjcveQ7LW+IHsrF6XXeOIdmd5tPPk3jWBhr3+Xv5l/wuXN9tvfv7xdhvb6+kWbrna3n8rNELu5c128o2q17m5Hdd46pqz6o0Yb39VXeO7jG/p1uuOa1z1HpK1xg9lZ/W66hpH9DvLo50n967D69jr72XY/8LT9fKbn68Wy1gdTxi8GCt3Xx8OSa9zczuu8dQ1p9UbMdz+qrrGD2V063XHNS57D8la4weys3pddo0j2p3l0c6Te9cEGvb6exn2v/DsyVG8fHH62e9+vPrlNF7/NvU3NEdxfjFO7hzfSOm1NZ5OTs159UaMtr+qrnHEePu6W27mGte9h2St8f7srF7XXeOIbmd5tPPk3jWFfr3+Xn5nf4+sv+p48vMmPt5uY7VYxtU/Pf6KZbeas+rNyo3Q6zl1q7njvnae5tOt5o7nqds7SES//dVxjbs9nzr2+r8y7A/m5CTi+jri+Dji6ir7aubRreaserv1OaJnr7vV3HFfZ+m4xt1q7nie1CwXKnucfQEAAADAYRn2AQAAoBjDPgAAABRj2AcAAIBiDPsAAABQjGEfAAAAijHsAwAAQDGGfQAAACjGsA8AAADFGPYBAACgGMM+AAAAFGPYBwAAgGIM+wAAAFCMYR8AAACKMewDAABAMYZ9AAAAKMawDwAAAMUY9gEAAKAYwz4AAAAUY9gHAACAYgz7AAAAUIxhHwAAAIpZZF/AQ95+2MTlzTaerpfx7MlRj+z1JparbcRiGRHz1pwmqeZ2a5y4t/R6Rt1qbrivnacZdau54Xny3tWg1w3XOHOG6mb0Xg877J9fvIs//np///PLF6fx5uyn0tnnF+9icfY+1vc/z1dzlqyau61x5t7S63l73anm7F5n7WvnyXmqlHuX3WlfZ+q2v7qucdYM1c2P0OtHu91ul30RX3r7YRO//v73V5/fXjyPuJn4G5P1JhZnX2f/+er5pN/W7Kt56txMWTWPljv5vt6zp52n+XI79tq+Prx2vbbG9zr2Oqtm713z5Vrjw+s4T2T5UXo95L/sX95sv/n5x9ttbK+nbd5ytb3/9u/La5py4fbVPHVupqyaR8udel/v29PO03y5HXttXx9et15b40869jqrZu9d8+Va48PrOE9k+VF6PeSw/3S9/Obnq8UyVscThy++nb3vmg5l339/6txMWTWPljv5vt6zp52n+XI79tq+Prx2vbbG9zr2Oqtm713z5Vrjw+s4T2T5UXo95LD/7MlRvHxx+tnvQLz65TRe/zbHtyRHcX7xdfbU39Dsq3mkb4YOLavm0XKn39ff3tPO03y5HXttXx9ev15b47vcjr3Oqtl713y51vjwOs4TWX6UXg/5O/t3Tn7exMfbbawWy7j6Z97GZWVn1pylW6/b/QXv0Os5dau5Y6+73TMzn4vd9nXH967R/5L2FOzr+jrWnGX0Xo897J9EXF9HHB9HXF31yM6sOYte16fXcDjd7pnuH/Pp+N5FfR33Vseas4ze68fZFwAAAAAclmEfAAAAijHsAwAAQDGGfQAAACjGsA8AAADFGPYBAACgGMM+AAAAFGPYBwAAgGIM+wAAAFCMYR8AAACKMewDAABAMYZ9AAAAKMawDwAAAMUY9gEAAKAYwz4AAAAUY9gHAACAYgz7AAAAUIxhHwAAAIox7AMAAEAxhn0AAAAoxrAPAAAAxRj2AQAAoBjDPgAAABSzyL6AB603sVxtIxbLiDjqkZ2U+/bDJi5vtvF0vYxnT/S6oo5rnFVzaq+TdOx1Wna3e2bivbrdvm743tVujZOzUzR734sI52lOg++vYYf984t3sTh7H+v7n0/jzdlPpbMzc//46/39zy9f6HU1Xdc4o+bMXmfp2OvMmjvdM7PfBTrt6+xee07U3tdZur3vRThPHd5xv8ej3W63y76IL739sIlff//7q89vL55H3Ez8jcl6E4uzhOxuuQ9k//nq+aTfyu3bX1PnZnGe8nOr7q2IxP2V2OtuNWfdMzPv1db4X54ThXIfyK76jOr2vhcx3v3aeco35L/sX95sv/n5x9ttbK+nbd5ytb3/dmbO7G65D2Vf3mwnPST79tfUuVmcp/zcqnsrIm9/Zfa6W81Z98zMe7U1/pfnRJ3ch7KrPqO6ve9FjHe/dp7yDTnsP10vv/n5arGM1fHE4Yuk7G65D2TvW/9D2fffnzo3i/OUn1t1b0Uk7q/EXnerOeuemXmvtsb/8pwolPtAdtVnVLf3vYjx7tfOU74hh/1nT47i5YvTz37/4tUvp/H6tzm+JTmK84uM7G65+7On/jZs3/4a6Vu4Q3Ke8nOr7q2IzP2V1+tuNWfdMzPv1dbYc6Je7v7sqs+obu97EePdr52nfEP+zv6dk5838fF2G6vFMq7+6fGXSrvlZmZn7q8MHc9TVs3t/tJxuHfZ19PJvHd167Xz1KPX3n/qc57mM/o739jD/knE9XXE8XHE1VX21VBNt/3Vrd6InjVTX7d9nVlvt1531HGNu9Xcrd5Mej2ex9kXAAAAAByWYR8AAACKMewDAABAMYZ9AAAAKMawDwAAAMUY9gEAAKAYwz4AAAAUY9gHAACAYgz7AAAAUIxhHwAAAIox7AMAAEAxhn0AAAAoxrAPAAAAxRj2AQAAoBjDPgAAABRj2AcAAIBiDPsAAABQjGEfAAAAijHsAwAAQDGGfQAAACjGsA8AAADFGPYBAACgmEX2BTxovYnlahuxWEbEUfbVzOLth01c3mzj6XoZz57MV3NWbmp20v7qVm9Ev5ozz1MW9y77ejKZ7wLNeu089eh1u/frhmvsPM1n9He+YYf984t3sTh7H+v7n0/jzdlPqdc0tfOLd/HHX+/vf375Yp6as3Izs7P2V7d677I71Zx5nrK4d9nXU+Zm3ru69dp56tHrTu/XXdfYeard6+/xaLfb7bIv4ktvP2zi19///urzP189H/Ibk0PYV/PtxfOImwlrXm9icZaQ+0D21Os8Wq+z6p3jPI3W66prnGm0Nbav6+dmrnG351Pmu0DV/TXiM7nqM8p5+sS9a77s0c7TkP+yf3mz3fv5SM07pH01f7zdxvZ6upqXq+39N3Bz5j6UPfU6j9brrHrnOE+j9brqGmcabY3t6/q5mWvc7fmU+S5QdX+N+Eyu+oxynj5x75ove7TzNOSw/3S9/K7PK9hX22qxjNXxhMGLpNwHsqde59F6nVXvHOdptF5XXeNMo62xfV0/N3ONuz2fMt8Fqu6vEZ/JVZ9RztMn7l3zZY92noYc9p89OYqXL04/+x2IV7+cDvUtyaHtq/n1b1PXfBTnFxm5+7OnXufRep1V7xznabReV13jTKOtsX1dPzdzjbs9nzLfBarurxGfyVWfUc7Tp2z3rvmyRztPQ/7O/p3R/7rhFE5+3sTH222sFsu4+me+mrNyI/LWuVuvM8+TXtfXsdfd7l0d/0J8t153fBfo2OvM7AzW2Hma0ujvfEMP+x2dnERcX0ccH0dcXdXPzaTX89Hr+vR6Pno9n2697lZvpsxeW+d5WOP5dKv3ezzOvgAAAADgsAz7AAAAUIxhHwAAAIox7AMAAEAxhn0AAAAoxrAPAAAAxRj2AQAAoBjDPgAAABRj2AcAAIBiDPsAAABQjGEfAAAAijHsAwAAQDGGfQAAACjGsA8AAADFGPYBAACgGMM+AAAAFGPYBwAAgGIM+wAAAFCMYR8AAACKMewDAABAMYZ9AAAAKMawDwAAAMUssi9gVG8/bOLyZhtP18t49uRovuD1JparbcRiGRENckOv55LW5wi9nlG386TX9Xvd8t6VpeG7QLdznJltjWfUbI073rv+K8P+N5xfvIs//np///PLF6fx5uynWXIXZ+9jff9z7dy7bL2eJzejz3fZeu08TZWr17V7nb3GWc/GDF3fBTqd48xsa2yNp8ztdu/6Ho92u90u+yJG8vbDJn79/e+vPr+9eB5xM+G3NetNLM6+zv3z1fNJvyVKqzdiuJrL9npPnzPX2HmagF7PkvtQdtmzPNgaV34+ZXGe8nMze132LA927+p4nsrurYgf5jnhX/a/cHmz/ebnH2+3sb2ebuGWq+39N1JfXs+UGyar3ojxaq7a6319zlxj5+nw9Hqe3Ieyq57l0da48vMpi/OUn5vZ66pnebR7V8fzVHVvRfw4zwnD/heerpff/Hy1WMbqeMLgxbdz913PoaTVGzFczWV7vafPmWvsPE1Ar2fJfSij7FkebI0rP5+yOE/5uZm9LnuWB7t3dTxPZfdWxA/znDDsf+HZk6N4+eL0s9+/ePXLabz+bepvaI7i/OLr3Km/GcqrN2K0muv2+tt9zlxj52kKej1H7kPZdc/yWGtc+fmUxXnKz83sdd2zPNa9q+N5qru3In6U54Tf2d/j5OdNfLzdxmqxjKt/6v8Vy45/0VrufLrVnHX/iOhXc8dey53P6H9l+dCcp/q5Ef3u19a4/hpn3rsys/8Lw/4eJycR19cRx8cRV1fZVwP8SDreP7Jq7thrmIrz1IP7dX3d1jhzb42+rx9nXwAAAABwWIZ9AAAAKMawDwAAAMUY9gEAAKAYwz4AAAAUY9gHAACAYgz7AAAAUIxhHwAAAIox7AMAAEAxhn0AAAAoxrAPAAAAxRj2AQAAoBjDPgAAABRj2AcAAIBiDPsAAABQjGEfAAAAijHsAwAAQDGGfQAAACjGsA8AAADFGPYBAACgGMM+AAAAFGPYBwAAgGIW2RfwkLcfNnF5s42n62U8e3I0b/h6E8vVNmKxjIj5slNrbqZbrzPrzcpOqznp/pEqq+aOvU7S7hwnZne8d3Xrdcd33G73a2vcIDc7+z8Ydtg/v3gXf/z1/v7nly9O483ZT7NlL87ex/r+53myM2vupluvs89TRnZmbsb9I1PmPbNbr7N0O8eZ2R3vXR173fEdt9P92hrXz83O/q8e7Xa7XfZFfOnth038+vvfX33+56vnk38zti/79uJ5xM2E2etNLM5yau4mc39lSNvTEXv3ddXz1G1vReTV3LHXWUZ7Lmbeu6ru6xHfu7Jqrvp8ihiv11Xv1yO+dzlPh/ej7Osh/2X/8ma79/Opm7cv++PtNrbX02UvV9v7b4W+vJ6RNkwFmfsrQ9aejti/r6uep257KyKv5o69zjLaczHz3lV1X4/43pVVc9Xn013Gvs+r7q8MI753OU+H96Ps6yGH/afr5Xd9Pkf2arGM1fGEwYu8mrvJ3F8Z0vZ0xN59XfU8ddtbEXk1d+x1ltGei5n3rqr7esT3rqyaqz6fHsqovL8yjPje5Twd3o+yr4cc9p89OYqXL04/+12XV7+czvItyb7s179NnX0U5xc5NXeTub8y5O3piH37uup56ra3IvJq7tjrLKM9FzPvXVX39YjvXVk1V30+RYzX66r36xHfu5ynw/tR9vWQv7N/5+TnTXy83cZqsYyrf/xVWA4rc39lyKw3KzvrPHXbWxHumR1k7euO7wIde+05MR/363l0/H8S6XjvGn1fjz3sn0RcX0ccH0dcXWVfDdV021+Z9eo1/Piy9nXH89Sx193WuVu99NDx3jW6x9kXAAAAAByWYR8AAACKMewDAABAMYZ9AAAAKMawDwAAAMUY9gEAAKAYwz4AAAAUY9gHAACAYgz7AAAAUIxhHwAAAIox7AMAAEAxhn0AAAAoxrAPAAAAxRj2AQAAoBjDPgAAABRj2AcAAIBiDPsAAABQjGEfAAAAijHsAwAAQDGGfQAAACjGsA8AAADFGPYBAACgGMM+AAAAFLPIvoAHrTexXG0jFsuIOMq+mlm8/bCJy5ttPF0v49mT+WrOyk3NTtpf3erNzG7Z6yTuXQ1qztrXiedJr2fkOTGbbveubrmpOt67BjfssH9+8S4WZ+9jff/zabw5+yn1mqZ2fvEu/vjr/f3PL1/MU3NWbmZ21v7qVm9mdsdeZ3Hvql9z5jnOvHfptefEVLkd97Xc+u8C3e5dP4JHu91ul30RX3r7YRO//v73V5//+ep52W/G9tV8e/E84mbCmtebWJwl5D6QPfU6t+t1Up8j9PqOe9cEBrx3la252706YriaO/a623nS6/lyq57jTKPduyr3+nsN+S/7lzfbvZ9XXbh9NX+83cb2erqal6vt/Tdhc+Y+lD31OnfrdVaf7zK+Ra/r6LbGmdmj5Va9V0eMV3PHXnc7T3o9X27Vc5xptHtX5V5/ryGH/afr5Xd9XsG+2laLZayOJwxeJOU+kD31OrfrdVKfH8rQ6zrarXFm9mC5Ze/VEcPV3LHX3c6TXs+XW/UcZxrt3lW5199ryGH/2ZOjePni9LPfdXn1y2npb2j21fz6t6lrPorzi4zc/dlTr3O/Xuf0OUKv73Ldu6Yw3r2rbs3d7tURo9XcsdfdzpNez5db9RxnGu3eVbnX32vI39m/c/LzJj7ebmO1WMbVPz0WLavmjn/RuluvO65xt72VqWOvu9Xcrd6Ifvcuz4n6uRHuIdVzM3U8T6Mbe9g/ibi+jjg+jri6yr6aeXSsOYteMxV7az4de92t5m71wtS6namserv1mTE9zr4AAAAA4LAM+wAAAFCMYR8AAACKMewDAABAMYZ9AAAAKMawDwAAAMUY9gEAAKAYwz4AAAAUY9gHAACAYgz7AAAAUIxhHwAAAIox7AMAAEAxhn0AAAAoxrAPAAAAxRj2AQAAoBjDPgAAABRj2AcAAIBiDPsAAABQjGEfAAAAijHsAwAAQDGGfQAAACjGsA8AAADFLLIv4EHrTSxX24jFMiKOZo1++2ETlzfbeLpexrMnM2Yn1ZxWb2Z24v7K0HGNO+4tvW6g23Oi4XnK4jlRPzci+t03s+pteO/qlpud/V8MO+yfX7yLxdn7WN//fBpvzn6aLfuPv97f//zyxTzZWTVn1ZuZnbm/MnRd4257S69rn+OIfs+Jjucpi+dE/dy77E73zcx7Zrd7V7fc7Oz/6tFut9tlX8SX3n7YxK+///3V53++ej75NyZZ2aPl3l48j7iZ+Nup9SYWZ+PUPMf+yjDieZp8f+3ZW2VzM7MHy616jiOcpzuV3wWyjPgu0G1fV37vyuLdesbsbrkPZI92nob8l/3Lm+3ez6duXlb2aLkfb7exvZ6218vV9v4bzy+vqWKvs4x4nqbeX/v2VtXczOzRcque4wjn6U7ld4EsI74LdNvXld+7sni3ni+7W+5D2aOdpyGH/afr5Xd9XiF7tNzVYhmr40mj/+93mL5WtddZRjxPk++vPXurbG5m9mC5Vc9xhPN0p/K7QJYR3wW67evK711ZvFvPmN0t94Hs0c7TkMP+sydH8fLF6We/A/Hql9NZviXJyh4t9/Vvc3wjdRTnF+PUPNK3cIc04nmafn99e2/Vzc3MHiu36jmOcJ7uciu/C2QZ8V2g276u/N6Vxbv1nNndcvdnj3aehvyd/TuZf93w5OdNfLzdxmqxjKt/5svulhuRt86ZNWfIrDcru+Pe6lbz6H8FdwrdnhMd711ZOr53dbtnZmdnsMb1z1PHe9d/NfSwn+nkJOL6OuL4OOLqSm5F3WrOrFev6+tYc5Zuzwn3rh669dq+rs8a9zB6rx9nXwAAAABwWIZ9AAAAKMawDwAAAMUY9gEAAKAYwz4AAAAUY9gHAACAYgz7AAAAUIxhHwAAAIox7AMAAEAxhn0AAAAoxrAPAAAAxRj2AQAAoBjDPgAAABRj2AcAAIBiDPsAAABQjGEfAAAAijHsAwAAQDGGfQAAACjGsA8AAADFGPYBAACgGMM+AAAAFGPYBwAAgGIW2RcwrPUmlqttxGIZEUdyJ/T2wyYub7bxdL2MZ0/q19yt3vTsDM7TbLFp9Wbq9pxoeO/K2tep56lZrzvu6yzWuP556njv+q8M+99wfvEuFmfvY33/82m8OftJ7kTZf/z1/v7nly9q19yt3uzsDNm97rS/surN1O05kX2eOu3rzPPUsdfd9nUWa9zjPHW7d32PR7vdbpd9ESN5+2ETv/7+91ef3148j7iZ8Nua9SYWZ+Pk/vnq+eTfjOn1v6budVqfI1L3V4Z9ve54nrL2ddW9FTHeGlfdWxF6fadjrz2T68h6Toz4LlB2X2fdMx/IHu08+Zf9L1zebL/5+cfbbWyvp1u45Wp7/63QCLmXN9vJN6pe/2vqXmf1OSJ3f2XY1+uO5ylrX1fdWxHjrXHVvXWX8S16fXij9dozuY6s58SI7wJV93XWPfOh7NHOk2H/C0/Xy29+vlosY3U8YfBirNx9fTgkvf7X1L1O63NE6v7KsK+ujucpa19X3VsR461x1b31UIZeH95ovfZMriPrOTHiu0DZfZ11z3wge7TzZNj/wrMnR/Hyxelnv/vx6pfTeP3b1N/QHMX5xTi5c3wjpdfz9DqvzxGZ+yvDvl53PE9Z+7rq3ooYb42r7q0Ivb7L7dhrz+Q6sp4TI74L1N3XWffM/dmjnSe/s7/Hyc+b+Hi7jdViGVf/1P9rkln1ZmZ363XmXyrN3F8ZnKf65ylTt153vHd1/IvW9vV8uv2/mFhj52lKo7+HGPb3ODmJuL6OOD6OuLrKvprpZdar1/V1q9l5mk+3ejN17HXHmruxxvVZ4/l07PXoNT/OvgAAAADgsAz7AAAAUIxhHwAAAIox7AMAAEAxhn0AAAAoxrAPAAAAxRj2AQAAoBjDPgAAABRj2AcAAIBiDPsAAABQjGEfAAAAijHsAwAAQDGGfQAAACjGsA8AAADFGPYBAACgGMM+AAAAFGPYBwAAgGIM+wAAAFCMYR8AAACKMewDAABAMYZ9AAAAKMawDwAAAMUY9gEAAKCYRfYFPOTth01c3mzj6XoZz54czRu+3sRytY1YLCNivuy0mpPqzczu1mvnqf4aZ2Z37HVWzR17nabZeUp9TmRptsaZ2d3uXc5Tk14P/mwcdtg/v3gXf/z1/v7nly9O483ZT7NlL87ex/r+53mys2rOqjczu1uvnaf6a5yZ3bXXWTV363WWjucp6zmRpdsaZ2Z3u3c5Tz16/SM8Gx/tdrtd9kV86e2HTfz6+99ffX578TziZuJvTNabWJx9nf3nq+eTflOUVnNSvRH9at5Xb9m9FbG3193W2L1rAll7KzN7sNw5nhNZ2u1ra3yvcq+71dyt3kyj9brye9f3GvJf9i9vtt/8/OPtNrbX0zZvudrefzvz5TVNuXBZNWfVe5fxLVVr3ldv1b0Vsb/X3dbYvevwsvZWZvZouXM8J7J029fW+JPKve5Wc7d6M43W68rvXd9ryGH/6Xr5zc9Xi2WsjicOX3w7e981HUpazUn1PpRRteZ9//2yeytib6+7rbF71wSy9lZm9mC5czwnsrTb19b4XuVed6u5W72ZRut15feu7zXksP/syVG8fHH62e9fvPrlNF7/Nse3JEdxfvF19tTf0OTVnFNvRL+a99Vbd29F7Ot1tzV275pC1t7KzB4rd6R/uTi0fvvaGkfU73W3mrvVm2m0Xld+7/peQ/7O/h1/qbR+bma23Pl0q1mv6+dmZnfLzdSt19a4R6+71dwtN1PHXo++zkMP+wAAAMD3e5x9AQAAAMBhGfYBAACgGMM+AAAAFGPYBwAAgGIM+wAAAFCMYR8AAACKMewDAABAMYZ9AAAAKMawDwAAAMUY9gEAAKAYwz4AAAAUY9gHAACAYgz7AAAAUIxhHwAAAIox7AMAAEAxhn0AAAAoxrAPAAAAxRj2AQAAoBjDPgAAABRj2AcAAIBiDPsAAABQjGEfAAAAijHsAwAAQDGGfQAAACjGsA8AAADFGPYBAACgGMM+AAAAFGPYBwAAgGIM+wAAAFCMYR8AAACKMewDAABAMYZ9AAAAKMawDwAAAMUY9gEAAKAYwz4AAAAU8/8Brqo+xRYhD2cAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(\"Initial graph\")\n",
    "cc, tree_ratio, squares = analytics(data)\n",
    "print(\"Number of connected component: \"+str(cc))\n",
    "print(\"Ratio of trees: \"+str(tree_ratio))\n",
    "print(\"Number of squares: \"+str(squares))\n",
    "draw_Data(data, width, height)\n",
    "\n",
    "print(\"Noise\")\n",
    "cc, tree_ratio, squares = analytics(noise)\n",
    "print(\"Number of connected component: \"+str(cc))\n",
    "print(\"Ratio of trees: \"+str(tree_ratio))\n",
    "print(\"Number of squares: \"+str(squares))\n",
    "draw_Data(noise, width, height)\n",
    "\n",
    "noise1 = deepcopy(noise)\n",
    "noise2 = deepcopy(noise)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generated tree\n",
      "Number of connected component: 132\n",
      "Ratio of trees: 0.8636363636363636\n",
      "Number of squares: 21\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "thresholds = torch.arange(start=0, end=width*height).flip(0).unsqueeze(1).to(device)\n",
    "\n",
    "for threshold in thresholds:\n",
    "    noise_pred = model.reverse(batch=noise1, thresholds=threshold)\n",
    "    \n",
    "    sample = torch.bernoulli(noise_pred).long()\n",
    "    noise1.edge_state = F.one_hot( sample, num_classes=2) * 1.\n",
    "\n",
    "    undirected_indices = (noise1.edge_index[0] < noise1.edge_index[1]) * noise1.csr()[2] + (noise1.edge_index[0] >= noise1.edge_index[1]) * noise1.csc()[2] \n",
    "    noise1.edge_state = noise1.edge_state[undirected_indices]\n",
    "    \n",
    "    noise1.edge_weight = noise1.edge_state[:,0]\n",
    "\n",
    "print(\"Generated tree\")\n",
    "cc, tree_ratio, squares = analytics(noise1)\n",
    "print(\"Number of connected component: \"+str(cc))\n",
    "print(\"Ratio of trees: \"+str(tree_ratio))\n",
    "print(\"Number of squares: \"+str(squares))\n",
    "draw_Data(noise1, width, height)"
   ]
  }
 ],
 "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.10.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}