jupyter_notebooks/routing_by_backprop_demo.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/krzysztofrusek/net2vec/blob/master/jupyter_notebooks/routing_by_backprop_demo.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install dm_haiku optax jraph\n",
        "!apt install xsltproc\n",
        "!git clone https://github.com/krzysztofrusek/net2vec.git"
      ],
      "metadata": {
        "id": "Y7WvDMQIlp29",
        "outputId": "e8bdc2c5-23c5-4a47-9114-96a1a3f83dea",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting dm_haiku\n",
            "  Downloading dm_haiku-0.0.7-py3-none-any.whl (342 kB)\n",
            "\u001b[K     |████████████████████████████████| 342 kB 13.5 MB/s \n",
            "\u001b[?25hCollecting optax\n",
            "  Downloading optax-0.1.3-py3-none-any.whl (145 kB)\n",
            "\u001b[K     |████████████████████████████████| 145 kB 54.2 MB/s \n",
            "\u001b[?25hCollecting jraph\n",
            "  Downloading jraph-0.0.6.dev0-py3-none-any.whl (90 kB)\n",
            "\u001b[K     |████████████████████████████████| 90 kB 8.4 MB/s \n",
            "\u001b[?25hRequirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from dm_haiku) (4.1.1)\n",
            "Requirement already satisfied: numpy>=1.18.0 in /usr/local/lib/python3.7/dist-packages (from dm_haiku) (1.21.6)\n",
            "Requirement already satisfied: absl-py>=0.7.1 in /usr/local/lib/python3.7/dist-packages (from dm_haiku) (1.2.0)\n",
            "Requirement already satisfied: tabulate>=0.8.9 in /usr/local/lib/python3.7/dist-packages (from dm_haiku) (0.8.10)\n",
            "Collecting jmp>=0.0.2\n",
            "  Downloading jmp-0.0.2-py3-none-any.whl (16 kB)\n",
            "Requirement already satisfied: jaxlib>=0.1.37 in /usr/local/lib/python3.7/dist-packages (from optax) (0.3.15+cuda11.cudnn805)\n",
            "Collecting chex>=0.0.4\n",
            "  Downloading chex-0.1.4-py3-none-any.whl (76 kB)\n",
            "\u001b[K     |████████████████████████████████| 76 kB 5.3 MB/s \n",
            "\u001b[?25hRequirement already satisfied: jax>=0.1.55 in /usr/local/lib/python3.7/dist-packages (from optax) (0.3.17)\n",
            "Requirement already satisfied: dm-tree>=0.1.5 in /usr/local/lib/python3.7/dist-packages (from chex>=0.0.4->optax) (0.1.7)\n",
            "Requirement already satisfied: toolz>=0.9.0 in /usr/local/lib/python3.7/dist-packages (from chex>=0.0.4->optax) (0.12.0)\n",
            "Requirement already satisfied: etils[epath] in /usr/local/lib/python3.7/dist-packages (from jax>=0.1.55->optax) (0.7.1)\n",
            "Requirement already satisfied: opt-einsum in /usr/local/lib/python3.7/dist-packages (from jax>=0.1.55->optax) (3.3.0)\n",
            "Requirement already satisfied: scipy>=1.5 in /usr/local/lib/python3.7/dist-packages (from jax>=0.1.55->optax) (1.7.3)\n",
            "Requirement already satisfied: importlib_resources in /usr/local/lib/python3.7/dist-packages (from etils[epath]->jax>=0.1.55->optax) (5.9.0)\n",
            "Requirement already satisfied: zipp in /usr/local/lib/python3.7/dist-packages (from etils[epath]->jax>=0.1.55->optax) (3.8.1)\n",
            "Installing collected packages: jmp, chex, optax, jraph, dm-haiku\n",
            "Successfully installed chex-0.1.4 dm-haiku-0.0.7 jmp-0.0.2 jraph-0.0.6.dev0 optax-0.1.3\n",
            "Reading package lists... Done\n",
            "Building dependency tree       \n",
            "Reading state information... Done\n",
            "The following package was automatically installed and is no longer required:\n",
            "  libnvidia-common-460\n",
            "Use 'apt autoremove' to remove it.\n",
            "The following NEW packages will be installed:\n",
            "  xsltproc\n",
            "0 upgraded, 1 newly installed, 0 to remove and 32 not upgraded.\n",
            "Need to get 14.0 kB of archives.\n",
            "After this operation, 158 kB of additional disk space will be used.\n",
            "Get:1 http://archive.ubuntu.com/ubuntu bionic-updates/main amd64 xsltproc amd64 1.1.29-5ubuntu0.3 [14.0 kB]\n",
            "Fetched 14.0 kB in 0s (331 kB/s)\n",
            "Selecting previously unselected package xsltproc.\n",
            "(Reading database ... 155685 files and directories currently installed.)\n",
            "Preparing to unpack .../xsltproc_1.1.29-5ubuntu0.3_amd64.deb ...\n",
            "Unpacking xsltproc (1.1.29-5ubuntu0.3) ...\n",
            "Setting up xsltproc (1.1.29-5ubuntu0.3) ...\n",
            "Processing triggers for man-db (2.8.3-2ubuntu0.1) ...\n",
            "Cloning into 'net2vec'...\n",
            "remote: Enumerating objects: 124, done.\u001b[K\n",
            "remote: Counting objects: 100% (51/51), done.\u001b[K\n",
            "remote: Compressing objects: 100% (42/42), done.\u001b[K\n",
            "remote: Total 124 (delta 11), reused 37 (delta 6), pack-reused 73\u001b[K\n",
            "Receiving objects: 100% (124/124), 1.65 MiB | 1.99 MiB/s, done.\n",
            "Resolving deltas: 100% (43/43), done.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%%bash\n",
        "\n",
        "curl -o sndlib-networks-xml.tgz http://sndlib.zib.de/download/sndlib-networks-xml.tgz\n",
        "\n",
        "tar -xvkf sndlib-networks-xml.tgz\n",
        "xsltproc -o janos-us.graphml net2vec/routing_by_backprop/topo/net2graphml.xslt sndlib-networks-xml/janos-us.xml"
      ],
      "metadata": {
        "id": "mFTJ_mw5mRuL",
        "outputId": "f9a2d3f1-d42b-4ed8-e333-91cc7732546e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "sndlib-networks-xml/abilene.xml\n",
            "sndlib-networks-xml/atlanta.xml\n",
            "sndlib-networks-xml/brain.xml\n",
            "sndlib-networks-xml/cost266.xml\n",
            "sndlib-networks-xml/dfn-bwin.xml\n",
            "sndlib-networks-xml/dfn-gwin.xml\n",
            "sndlib-networks-xml/di-yuan.xml\n",
            "sndlib-networks-xml/france.xml\n",
            "sndlib-networks-xml/geant.xml\n",
            "sndlib-networks-xml/germany50.xml\n",
            "sndlib-networks-xml/giul39.xml\n",
            "sndlib-networks-xml/india35.xml\n",
            "sndlib-networks-xml/janos-us-ca.xml\n",
            "sndlib-networks-xml/janos-us.xml\n",
            "sndlib-networks-xml/newyork.xml\n",
            "sndlib-networks-xml/nobel-eu.xml\n",
            "sndlib-networks-xml/nobel-germany.xml\n",
            "sndlib-networks-xml/nobel-us.xml\n",
            "sndlib-networks-xml/norway.xml\n",
            "sndlib-networks-xml/pdh.xml\n",
            "sndlib-networks-xml/pioro40.xml\n",
            "sndlib-networks-xml/polska.xml\n",
            "sndlib-networks-xml/sun.xml\n",
            "sndlib-networks-xml/ta1.xml\n",
            "sndlib-networks-xml/ta2.xml\n",
            "sndlib-networks-xml/zib54.xml\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current\n",
            "                                 Dload  Upload   Total   Spent    Left  Speed\n",
            "\r  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0\r  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0\r100  775k  100  775k    0     0  2971k      0 --:--:-- --:--:-- --:--:-- 2960k\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "rCTOOTiRll96",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "31fb9db9-1be6-4a46-9d8e-a336bc7f8313"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/haiku/_src/data_structures.py:37: FutureWarning: jax.tree_structure is deprecated, and will be removed in a future release. Use jax.tree_util.tree_structure instead.\n",
            "  PyTreeDef = type(jax.tree_structure(None))\n"
          ]
        }
      ],
      "source": [
        "import itertools as it\n",
        "import functools\n",
        "import pickle\n",
        "from typing import Tuple\n",
        "\n",
        "import chex\n",
        "import haiku as hk\n",
        "import jax\n",
        "import jax.numpy as jnp\n",
        "import jraph\n",
        "import matplotlib.pyplot as plt\n",
        "import networkx as nx\n",
        "import numpy as np\n",
        "import optax\n",
        "import seaborn as sns\n",
        "\n",
        "sns.set()"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Toy model\n",
        "Let us begin with a simple toy model showing our approach.\n",
        "Assume we wish to minimize the piece-wise constant function $f(x)$ presented in the figure below. Since the gradient of $f$ is 0 almost everywhere, gradient methods cannot be applied. However, we can approximate the staircase function $f(x)$ with a neural network $\\hat f(x)$. \n",
        "\n",
        "\n",
        "![staircase.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "collapsed": false,
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "5aof4We0ll-A"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:absl:No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[-0.40087595]\n",
            " [-0.43607905]\n",
            " [ 0.29376148]\n",
            " [-1.1912414 ]\n",
            " [ 0.56265697]] [[ 1.]\n",
            " [ 1.]\n",
            " [ 1.]\n",
            " [ 3.]\n",
            " [-0.]]\n"
          ]
        }
      ],
      "source": [
        "# Define the piece-wise constant function f(x)\n",
        "def stair_case_function(x: chex.Array) -> chex.Array:\n",
        "    p = jnp.poly(-jnp.array([-1, -0.5, 0.5, 1]))\n",
        "    smooth = jnp.polyval(p, x) / 0.2\n",
        "    return jnp.ceil(smooth), smooth\n",
        "\n",
        "# Create samples for the f(x) function between x values -1.2 and 1.2\n",
        "x = np.linspace(-1.2, 1.2, 100)\n",
        "y, ysmooth = stair_case_function(x)\n",
        "\n",
        "# Preparing the training dataset\n",
        "xtrain = np.random.uniform(low=x[0], high=x[-1], size=(128, 1))\n",
        "ytrain, _ = stair_case_function(xtrain)\n",
        "\n",
        "# Show the first 5 samples and the corresponding labels\n",
        "print(xtrain[:5], ytrain[:5])"
      ],
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "LjKke9ewll-A",
        "outputId": "e299d1b8-f731-483a-c455-00e9a6211f17",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create the NN model\n",
        "@hk.transform\n",
        "def nn(x):\n",
        "    return hk.nets.MLP([16, 1], activation=jax.nn.tanh)(x)\n",
        "\n",
        "rng = jax.random.PRNGKey(42)\n",
        "\n",
        "params = nn.init(rng, xtrain)\n",
        "opt = optax.adam(0.01)\n",
        "\n",
        "opt_state = opt.init(params)\n",
        "\n",
        "def loss(params, x, y):\n",
        "    yhat = nn.apply(params, None, x)\n",
        "    return jnp.mean(optax.l2_loss(yhat, y))\n",
        "\n",
        "grad_loss = jax.jit(jax.grad(loss))\n",
        "\n",
        "@jax.jit\n",
        "def step(params, opt_state, x, y):\n",
        "    grads = jax.grad(loss)(params, xtrain, ytrain)\n",
        "    updates, opt_state = opt.update(grads, opt_state, params)\n",
        "    params = optax.apply_updates(params, updates)\n",
        "    return params, opt_state\n",
        "\n",
        "# Training\n",
        "for _ in range(1000):\n",
        "    params, opt_state = step(params, opt_state, xtrain, ytrain)\n",
        "\n",
        "\n",
        "# %%\n",
        "@jax.jit\n",
        "def grad_fn(params, rng, x):\n",
        "    @functools.partial(jax.vmap, in_axes=(0, None, None))\n",
        "    @jax.grad\n",
        "    def fn(x, params, rng):\n",
        "        return nn.apply(params, rng, jnp.expand_dims(x, 0))[0]\n",
        "\n",
        "    return fn(x, params, rng)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GYSTnLApuqPo",
        "outputId": "446664a7-e89c-4956-83ad-a76d49a476fa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/haiku/_src/base.py:497: UserWarning: Explicitly requested dtype float64 requested in zeros is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n",
            "  param = init(shape, dtype)\n",
            "/usr/local/lib/python3.7/dist-packages/haiku/_src/data_structures.py:144: FutureWarning: jax.tree_flatten is deprecated, and will be removed in a future release. Use jax.tree_util.tree_flatten instead.\n",
            "  leaves, treedef = jax.tree_flatten(tree)\n",
            "/usr/local/lib/python3.7/dist-packages/haiku/_src/data_structures.py:145: FutureWarning: jax.tree_unflatten is deprecated, and will be removed in a future release. Use jax.tree_util.tree_unflatten instead.\n",
            "  return jax.tree_unflatten(treedef, leaves)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The NN is differentiable, so we can surrogate the objective gradient by the gradient of the approximation $\\nabla \\hat f(x)$ in gradient descent. Notice that the sign of the surrogate gradient shows the correct monotonicity of the function."
      ],
      "metadata": {
        "id": "e4YcfBxI4Sn6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Make inference with trained NN and compute the gradients\n",
        "yhat = nn.apply(params, rng, x[..., np.newaxis])[:, 0]\n",
        "grads = grad_fn(params, rng, x)\n",
        "\n",
        "fig, ax = plt.subplots( constrained_layout=True)\n",
        "\n",
        "sns.lineplot(x=x, y=y, label='$f(x)$', ax=ax)\n",
        "sns.lineplot(x=x, y=yhat, label='$\\hat f(x)$', ax=ax)\n",
        "ax = sns.lineplot(x=x, y=0.1 * grads, label=r'$\\nabla \\hat f(x)$', ax=ax)\n",
        "ax.lines[2].set_linestyle(\"--\")\n",
        "plt.legend(ncol=3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 330
        },
        "id": "GhVa3foSwyIu",
        "outputId": "dff47432-fea9-476e-a5ed-6f6aa134568a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7fec3e0cb310>"
            ]
          },
          "metadata": {},
          "execution_count": 6
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "point=jnp.array([[-1.1]])\n",
        "\n",
        "@jax.jit\n",
        "@jax.grad\n",
        "def nabla(x):\n",
        "  return nn.apply(params, rng, x).sum() #sum make it scalar\n",
        "\n",
        "\n",
        "points=[point]\n",
        "grads_list = list()\n",
        "\n",
        "for _ in range(100):\n",
        "  point = point - 0.001*nabla(point)\n",
        "  points.append(point)\n",
        "  grads_list.append(nabla(point)[0,0])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PcDFbOAx4W8I",
        "outputId": "21f43489-331a-488b-f5d3-6429466c499b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/haiku/_src/data_structures.py:144: FutureWarning: jax.tree_flatten is deprecated, and will be removed in a future release. Use jax.tree_util.tree_flatten instead.\n",
            "  leaves, treedef = jax.tree_flatten(tree)\n",
            "/usr/local/lib/python3.7/dist-packages/haiku/_src/data_structures.py:145: FutureWarning: jax.tree_unflatten is deprecated, and will be removed in a future release. Use jax.tree_util.tree_unflatten instead.\n",
            "  return jax.tree_unflatten(treedef, leaves)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "surogates = np.asarray(nn.apply(params, rng, jnp.concatenate(points)))\n",
        "plt.plot(stair_case_function(np.concatenate(points)[:,0])[0], label='stair_case_function')\n",
        "plt.plot(surogates,label='surogate')\n",
        "plt.plot(grads_list, label='gradient')\n",
        "plt.xlabel('step')\n",
        "plt.legend(loc=\"lower right\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 302
        },
        "id": "RlnW_8BH4ZOi",
        "outputId": "03a1d199-41c6-42ad-801b-a56b07be347f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7fec4030db10>"
            ]
          },
          "metadata": {},
          "execution_count": 8
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Inference on real network\n",
        "\n",
        "In this section we are going to show how to load a pre-trained model and make a simple inference over a real-world network."
      ],
      "metadata": {
        "collapsed": false,
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "0Aa0AHMull-B"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "# Load the real-world network\n",
        "G = nx.read_graphml(\"janos-us.graphml\")\n",
        "G = nx.convert_node_labels_to_integers(G)\n",
        "G = nx.DiGraph(G)\n",
        "w = {k: 1. for k in G.edges}\n",
        "nx.set_edge_attributes(G, w, name='weight')\n",
        "\n",
        "all_pairs = dict(nx.all_pairs_dijkstra_path(G, weight='weight'))\n",
        "G.graph['all_pairs']=all_pairs\n",
        "pos =  {k:[float(v['x']),float(v['y'])] for k,v in G.nodes.data()}\n",
        "nx.draw_networkx(G, pos=pos)"
      ],
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "33DoRhgHll-C",
        "outputId": "49b03ead-1e71-4e13-bb68-cab3001124b0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 248
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Utility functions"
      ],
      "metadata": {
        "collapsed": false,
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "F4euZYW0ll-C"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "outputs": [],
      "source": [
        "def pairwise(iterable):\n",
        "    \"s -> (s0,s1), (s1,s2), (s2, s3), ...\"\n",
        "    a, b = it.tee(iterable)\n",
        "    next(b, None)\n",
        "    return zip(a, b)\n",
        "\n",
        "def to_jraph(G:nx.Graph, src:int, dst:int)->Tuple[jraph.GraphsTuple, chex.Array]:\n",
        "        nnodes = len(G)\n",
        "        routing = G.graph['all_pairs']\n",
        "        ledges = list(G.edges)\n",
        "        relation_data = np.array(list(G.edges.data('weight')))\n",
        "\n",
        "        nodes = np.zeros((nnodes, 2))\n",
        "        nodes[src, 0] = 1\n",
        "        nodes[dst, 1] = 1\n",
        "        nodes = jnp.array(nodes)\n",
        "\n",
        "\n",
        "        senders, receivers = jnp.split(relation_data[:, :2].astype(np.int32), 2, 1)\n",
        "        edges = jnp.array(relation_data[:, 2:])\n",
        "\n",
        "        x = jraph.GraphsTuple(\n",
        "            n_node=jnp.asarray([nodes.shape[0]]),\n",
        "            n_edge=jnp.asarray([edges.shape[0]]),\n",
        "            nodes=nodes,\n",
        "            edges=edges,\n",
        "            senders=senders.flatten(),\n",
        "            receivers=receivers.flatten(),\n",
        "            globals=None\n",
        "        )\n",
        "        y = np.zeros((relation_data.shape[0],1))\n",
        "\n",
        "        path = [ledges.index(e) for e in pairwise(routing[src][dst])]\n",
        "        y[path,0] = 1\n",
        "        return x,y"
      ],
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "YYXm4D44ll-D"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## The model\n",
        "\n",
        "Our model maps a weighted graph to a soft routing representing the probabilities that each link belongs to the shortest path between two given nodes."
      ],
      "metadata": {
        "collapsed": false,
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "RV_d4XJrll-D"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "outputs": [],
      "source": [
        "NUM_LAYERS = 2  # Hard-code number of layers in the edge/node/global models.\n",
        "LATENT_SIZE = 128  # Hard-code latent layer sizes for demos.\n",
        "\n",
        "\n",
        "class MLPModule(hk.Module):\n",
        "  def __call__(self, x, is_training=False)->jnp.ndarray:\n",
        "    x=hk.nets.MLP([LATENT_SIZE] * NUM_LAYERS,activate_final=True)(x)\n",
        "    x = hk.LayerNorm(axis=1, create_offset=True, create_scale=True)(x)\n",
        "    return x\n",
        "\n",
        "\n",
        "def network_definition(graph: jraph.GraphsTuple) -> jraph.GraphsTuple:\n",
        "    latent = jraph.GraphMapFeatures(MLPModule(), MLPModule())(graph)\n",
        "    latent0 = latent\n",
        "    outputs = []\n",
        "\n",
        "    core = jraph.GraphNetwork(\n",
        "        update_edge_fn=jraph.concatenated_args(MLPModule()),\n",
        "        update_node_fn=jraph.concatenated_args(MLPModule())\n",
        "    )\n",
        "    decoder = jraph.GraphMapFeatures(MLPModule(), MLPModule())\n",
        "\n",
        "    output_transform = jraph.GraphMapFeatures(\n",
        "        embed_edge_fn=hk.Linear(1)\n",
        "    )\n",
        "\n",
        "    num_message_passing_steps = 8\n",
        "    for _ in range(num_message_passing_steps):\n",
        "        core_input = latent._replace(\n",
        "            nodes=jnp.concatenate((latent.nodes, latent0.nodes), axis=1),\n",
        "            edges=jnp.concatenate((latent.edges, latent0.edges), axis=1)\n",
        "        )\n",
        "        latent = core(core_input)\n",
        "        decoded = decoder(latent)\n",
        "        outputs.append(output_transform(decoded))\n",
        "\n",
        "    return outputs"
      ],
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "6zhdRTPNll-E"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let's load a pretrained model as training from scratch would take ~30 min. Below we provide a small example of how to train the model from scratch."
      ],
      "metadata": {
        "collapsed": false,
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "1RXOzxwQll-E"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/haiku/_src/data_structures.py:144: FutureWarning: jax.tree_flatten is deprecated, and will be removed in a future release. Use jax.tree_util.tree_flatten instead.\n",
            "  leaves, treedef = jax.tree_flatten(tree)\n",
            "/usr/local/lib/python3.7/dist-packages/haiku/_src/data_structures.py:145: FutureWarning: jax.tree_unflatten is deprecated, and will be removed in a future release. Use jax.tree_util.tree_unflatten instead.\n",
            "  return jax.tree_unflatten(treedef, leaves)\n"
          ]
        }
      ],
      "source": [
        "with open('net2vec/routing_by_backprop/log/labsim/sp1/snapshot-8000.pickle', 'rb') as f:\n",
        "    params, state = pickle.load(f)"
      ],
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "a8yD9bvFll-F",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "059268b3-de0a-4d35-8c96-295a943d3f1c"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now we can evaluate the model and compare its prediction with Dijkstra algorithm"
      ],
      "metadata": {
        "collapsed": false,
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "bfb7KCsxll-F"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "outputs": [],
      "source": [
        "# Specify the src and destination nodes \n",
        "src = 0\n",
        "dst = 7\n",
        "\n",
        "x,y = to_jraph(G,src,dst)"
      ],
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "gwQ0vnQlll-F"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "outputs": [],
      "source": [
        "network = hk.without_apply_rng(hk.transform_with_state(network_definition))\n",
        "hats, _ = network.apply(params, state, x)"
      ],
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "gFrhoSJkll-G"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 864x288 with 2 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqsAAAD3CAYAAAA6yB1UAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydeXwV1fn/3zNzl9zs+0oCSdhCwhIIouCGogJVXOoCFX+ltra0Kq7dtVbb2sWqVdqvda22atVaV6q1rkFllwACsiQhJCGQfd9u7sz5/TEmJGS7Cffe3MTzfr18GWbmzjznztzPPOec5zyPIoQQSCQSiUQikUgkfog60gZIJBKJRCKRSCT9IZ1ViUQikUgkEonfIp1ViUQikUgkEonfIp1ViUQikUgkEonfIp1ViUQikUgkEonfIp1ViUQikUgkEonfIp3VMcorr7zCihUrRuz63/nOd3j11Ve9cm6n08nSpUupqKhw+zNvvPEG1157bde/s7OzKSkpAeAnP/kJDz74oMftHAyn08nixYupqanx+bUlEslXg3fffZezzjqL7Oxs9u7dO9LmUFZWRnZ2Nrquj7QpklGEdFZHgHPOOYcNGzb02DbSzuXJsHbtWm6//fYe25544gkuvfRSr1zvxRdfJCcnh9jYWMB0NrOyssjOziY7O5sLL7yQ+++/n8bGxq7PLFu2jKeeeqrr33l5eSQnJw/bhs2bN3PmmWcOvxGAzWbj61//Oo899thJnUcikYxttm3bxvLly5kzZw6nnHIKy5cvZ9euXW599ve//z133nkneXl5hIaGMmXKFFwul5ctPs6J77vExETy8vLQNM1nNkhGP9JZHQOcrPD4Urg8wQsvvMDFF1/cY9u3v/1t8vLy2LRpE/feey87duxgxYoVtLS0jJCV7n2vF110Ea+++ipOp9MHFkkkktFGU1MTq1evZuXKlWzZsoX169dzww03YLPZ3Pp8WVkZkyZNGvb1R9v7QTI2kc6qn/LYY4+xaNEisrOzWbp0Ke+++27XvldeeYXly5dz7733Mm/ePNauXUttbS2rV69m9uzZXH755RQXF/d77tLSUqZMmcK//vUvzj77bL75zW9iGAb/93//x8KFCznttNP40Y9+1DUy2dcoYmdvef369Tz66KO8/fbbZGdns2zZMgCuueYa/vWvf3XZu2LFCn7/+98zd+5czjnnHHJzc7vOVVJSwtVXX012djarVq3i7rvv7jVS20lZWRklJSXMnDmzz/12u50ZM2bwyCOPUFdXxyuvvNLDhk6mTJnC4cOHe32+qamJa665hl//+tcIIcjNzWXp0qVkZ2dzxhln8OSTT9LS0sJ1111HRUVF12hueXk5a9euZc2aNdx+++3Mnj2bV199lV27dnHVVVeRk5PD6aefzj333NPDMY2PjycsLIwdO3b0e78kEslXl0OHDgFw4YUXomkaAQEBnH766UydOhWgX+12Op1d0+0XX3wxixYtYuXKlQDMnTuX7Oxs8vLyel2vLx0rLy9n9erVnHLKKZx33nm89NJLXcefGEbV/X3xwx/+kLKyMlavXk12djaPP/541/un0wm+5ppr+NOf/sTy5cvJzs7m2muv7REa9dprr7Fw4ULmzZvHX/7ylz5nJiVjH+ms+inJyck899xzfPbZZ9xwww388Ic/7BGjuWvXLpKTk/n000/5/ve/zz333IPdbueTTz7h3nvv5d///veg19i6dStvvfUWTz75JK+88gqvvvoqf//733nvvfdoaWnhnnvuGfQcZ555Jt/73vdYsmQJeXl5vPHGG30et2vXLlJTU9m0aRPf+c53+PnPf05npd/bb7+dGTNmsHnzZm644QZef/31fq934MABkpOTsVgsA9oVHBzM/Pnz2bZt26Bt6KS2tpZVq1Yxe/Zs7rjjDhRF4ec//zn33HMPeXl5rFu3jlNPPZXAwEAef/xxYmNjycvLIy8vj7i4OADef/99Fi9ezLZt27joootQVZWf/vSnbNq0iRdeeIGNGzfy/PPP97huWloa+/btc9tOiUTy1SE1NRVN0/jxj39Mbm4u9fX1Pfb3p902m63LGX399dd57733ePbZZwFT+/Py8sjOzu7zmifq2K233kp8fDwff/wxDz/8MA888AAbN24c1Pb77ruPxMRE/vrXv5KXl8d1113X53Hr1q3jt7/9LRs3bqSjo6MrZCs/P5+7776b++67j48//pimpibKy8vd/u4kYwfprI4Q119/PTk5OV3/3X333T32L1myhLi4OFRVZenSpYwfP75HjFJsbCzXXHMNFosFq9XK//73P9asWUNgYCCTJ092K170xhtvJDAwkICAAN58801WrVpFcnIyQUFB3Hrrrbz11lsemwJKTEzkyiuvRNM0Lr30UiorK6mqqqKsrIzPP/+cNWvWYLPZyMnJ4Zxzzun3PA0NDQQFBbl1zdjY2F7C3h8VFRVcc801LF68mFtuuaVru8ViIT8/n6amJsLCwsjMzBzwPLNmzWLRokWoqkpAQABZWVnMmjULi8XCuHHjuOqqq9i6dWuPzwQFBdHQ0OCWnRKJ5KtFcHAwzz//PIqicOedd3LaaaexevVqqqqqALyi3d11rLa2lu3bt3P77bdjt9vJyMjgiiuuGHBQYahcdtllpKamEhAQwOLFi/niiy8A+O9//8vChQvJycnBZrOxZs0aFEXx2HUlowfprI4Qf/nLX9i2bVvXf3fddVeP/a+99hoXX3xxlzN78OBBamtru/bHx8d3/V1TU4PL5SIhIaFrW2Ji4qA2dD9HRUUFSUlJXf9OSkrC5XJRXV09rPadSHR0dNffDocDgJaWFioqKggLC+vaBvRox4mEhYXR3Nzs1jXLy8sJCwtz69jc3Fza2tpYvnx5j+0PP/wwubm5LFy4kJUrV/Y5bdad7t8pmFN43/ve91iwYAGzZ8/mwQcf7HEfAZqbmwkNDXXLTolE8tUjPT2d3/3ud6xfv54333yTiooK7r33XsA72n3iuyEsLIzg4OCubYmJiR4d4YyJien62+FwdK01qKio6GGLw+EgPDzcY9eVjB6ks+qHHDlyhDvuuIM777yTzZs3s23btl4B8t17l5GRkVgsFo4ePdq1rfvf/dH9HLGxsRw5cqTr32VlZVgsFqKionA4HLS1tXXt03W9R0zRyfR0Y2JiqK+vp7W11S3bp0yZQmlp6aCjBs3NzWzcuJGcnBy37Ljiiis444wz+O53v9tjUVZn/OuGDRtYtGgRN998M9B/m0/c/stf/pK0tDTeeecdtm/fzi233NIV/tBJYWFhV/yZRCKRDER6ejqXXXYZBw8eBAbW7hNxV6tPfDfU19fT1NTUte3o0aNdoU8nvh86R3w9QWxsbA+nuK2tjbq6Oo+dXzJ6kM6qH9La2oqiKERGRgLw73//u0uY+kLTNM477zz+/Oc/09raSn5+/pBznF544YU888wzlJSU0NzczIMPPsiSJUuwWCykpqbS3t7ORx99REdHB4888kiPRUJRUVEcOXIEwzCG3NakpCSysrJYu3YtTqeTvLw8Pvzww36Pj4+PJyUlpd+0LU6nk927d3P99dcTGhrKZZdd5rYtv/jFL0hNTWX16tW0tbXhdDp54403aGxsxGq1EhQUhKqaP5moqCjq6up6pMfqi+bmZoKCgggKCqKgoIB//vOfPfaXl5dTX1/PrFmz3LZTIpF8dSgoKOCpp57i2LFjgOkorlu3rmuR6UDafSKRkZGoqtqVY9odEhISyM7O5oEHHqC9vZ19+/bx8ssvdy2mzcjIIDc3l7q6OiorK3nmmWd6fD46OnpI1+vOBRdcwAcffMD27dtxOp2sXbu2V2df8tVAOqt+yMSJE7n22mtZvnw58+fP58CBA8yePXvAz/ziF7+gpaWFBQsW8JOf/GRIThrA17/+dZYtW8bKlSs599xzsdls3HnnnQCEhIRw1113cccdd3DmmWficDh6TM0sXrwYgHnz5g0rt+of//hHduzYwbx58/jTn/7E0qVLB0zLsnz58l7xUk8++STZ2dnMmzePH//4x2RmZvLCCy8QGBjoth2KovCrX/2K+Ph4fvCDH+B0Onn99dc555xzmD17Ni+88AL33XcfYI5ufO1rX2PRokXk5OT0OyX24x//mHXr1jF79mzuvPNOli5d2mP/m2++ySWXXOJ2GhqJRPLVIjg4mJ07d3LFFVcwa9YsrrzySiZPnsxPfvITYGDtPhGHw8Hq1atZsWIFOTk5bmcheeCBBzhy5AhnnHEGN9xwAzfeeCPz588H4OKLL2bq1Kmcc845XHvttb007rvf/S6PPPIIOTk5PPnkk0Nq+6RJk7jzzju59dZbOeOMMwgMDCQyMlLq5VcQRchuisTPuPnmm0lLS2PNmjV97nc6nVxyySU8/fTTXYUBhoJhGGRkZPDhhx+6FdvrLZxOJ8uWLeO5557rc8pOIpFIJMdpbm5m7ty5vPPOOydV1EUy+pAjq5IRZ9euXRQXF2MYBuvXr+f9999n0aJF/R5vs9l46623huWogpn+ym6391j0NRLYbDb++9//SkdVIpFI+uGDDz6gtbWVlpYWfv/73zN58mTGjRs30mZJfMzAySolEh9QVVXFjTfeSF1dHfHx8fzyl79k2rRpXrnWO++8wy9+8Qtuv/12OZUkkUgkfs7777/Pj370I4QQZGVl8cADD8j0VV9BZBiARCKRSCQSicRvkWEAEolEIpFIJBK/RTqrEolEIpFIJBK/ZdCY1draZgzDvyIFoqKCqa5uGvxAP0a2wT+QbfAPvNEGVVWIiHCvNO9Ywh81G0b/czra7QfZBn9BtqFvBtLsQZ1VwxB+KXz+aNNQkW3wD2Qb/IOx0AZ/wF81G0b/PR7t9oNsg78g2zA0ZBiARCKRSCQSicRvkc6qRCKRSCQSicRvkc6qRCKRSCQSicRvkc6qRCKRSCQSicRvkc6qRCKRSCQSicRvkc6qRCKRSCQSicRvkc6qRCKRSCQSicRvGTTPqjepbKnkxX3PsadmD43t9YTYw8iMzGR5xkqiHdEjaZpEIpFITkBqtkQiGQlGxFnNK/+Mh7bfz/vF76Kg0Ka3de37jxbA77f+hnNTzuem2beSHTdnJEyUSCQSyZdIzZZIJCOJz8MAnt79BJe8vpS3D/2Hdr29h+gBtOlttOvtvH1oHZe8vpSndz/haxMlEolE8iVSsyUSyUjj05HVp3c/wV0bfk6rq3XQYwWCVlcrd234OQCrsr7jbfMkEolE0g2p2RKJxB/w2chqXvlnbotedzrFb0fFdi9ZJpFIJJITkZotkUj8BZ85qw9tv582V1uv7UqbQsT/Ioh/Kp7Y52Nx5Dt6HdPmauOh7ff7wkyJRCKRIDVbIpH4Dz5xVitbKnm/+F0Eote+sE/DQIXya8qpO6eOsI/DsNT0jE4QCN47/D+qWqt8Ya5EIpF8pZGaLZFI/AmfOKsv7nsOBaXXdqVDwXHIQUNOA8IqcMY7aRvfhuNg7566gsKL+57zhbkSiUTylUZqtkQi8Sd84qzuqdnTawUpgFavIRSBHq53beuI6sBaa+11bJvext7qPV61UyKRSCRSsyUSiX/hE2e1sb2+74t3qAhbz2kmYRMoHb179AD17XUet00ikUgkPZGaLZFI/AmfOKsh9rA+txtWA8XZU+SUDgVh7R0nBRBmD/e4bRKJRCLpidRsiUTiT/jEWc2MzCRAC+i1XQ/TUYSCVq91bbNWW+mI6Oh1bIAWwLSoTK/aKZFIJBKp2RKJxL/wibN61dSr+1xVKqyCtglthGwLQelQsB2zEVAUQOuk3nn9BIKrpl7tC3MlEonkK43UbIlE4k/4xFmNCYzh3JTz+lxdWnd6HYpLIe4fcYS/H079GfW4Il09jlFQWDT+fKId0b4wVyKRSL7SSM2WSCT+hM/Krd40+zY+LHm/VzUUESCovaB2wM8GWAK4afZt3jRPIpFIJN2Qmi2RSPwFn1Wwyo6bw93zf4PD0jsf30AEaA7unv8bZsXO9pJlEolEIjmR4Wq2Zli467RfS82WSCQew2fOKsCqrO90iV9f00vdUVBwaA6uDPst01quo7HRR0ZKJBKJBBieZsftSOXTP5VSUeEjIyUSyZjHp84qmOL3+iVvszTtQuyavdeK0wAtALtmZ2nahbx+6dt8e+a32bZNY9s2lf37FYqKFHS9n5NLJBKJxKMMVbNf+dn7fPbZR9x9958pKFDYv1+hrXd9AYlEInEbn8WsdmdW7Gz+tvg5qlqreHHfc/zjf89CAMzJzGZaVCZXTb26KzC/OUiQmWlQUKCiKAYJCQLRd0o/iUQikXiBEzV7a/F2yuurSEtM6qXZrki4775/cfPNXyMiIpKrrlqJYUjRlkgkw2dEnNVOoh3R/GDWTez6aznx8fHcvWhNr2OCgiA0FBISBOXlCvPmGVhG1GqJRCL5ahLtiOb67Jv43FLH3r01XL4wDU3reYzFAunpcfz0py/y619fQlZWBNOnLxkZgyUSyZhgxN2+5maoqFBwuVTa2iCgdx5qNA1mzNDRddi5UyUx0fd2SvyHmhYn6/aUc7CymSani2CbhUkxQVyUGUdEoG2kzZNIxjSGAXl5KoWFKjU1CjExvUdNbTaYMyedJ574B9ddt4L4+HCuuOL8EbBW4g9IzZacLCPqrAoBDQ3gcBgEB6s0NfXtrGZkmKOpigI2m8Hu3RAbC1ar722WjBx7jjXy9JZiNhyqAcCpH39Jfpiv8uiGIuanRrLqlBQy40NGykyJZEzT0ACRkYL6emhpMZ1X9YTVD4mJZriWps1k7dq/cv313yY5+S3S0yeMiM2SkUFqtsRT+HyBVXfq6mDvXg0hDCwWhc8+02hq6n2c1Wo6qgDx8eY00/79A69MlYwtXt5ZxuqXdpKbX41TFz1ED6DdZeDUBbn51ax+aScv7ywbIUslkrFLezts367hdAocDoP9+1XKy3trsarSFR6waNGZ/Oxnv+Pyyy+loKDItwZLRgyp2RJPMqLOqt0O8+fraBo4HLBgge7WaGlWFjgcggMHFAzD+3ZKRpaXd5bxUG4hbS6jjwKQPRFAm8vgodxCKX4SiYfRNDjlFJ2YGIGqKpx1lk5IyOCLp66+ehm33PJjVqy4iiNHKn1gqWQkkZot8TQjGgYQGGj+PzpaJyYGgoPd/2xaGmzfrlBSAuPHy5WmY5U9xxq7RK87ou4o+pbnEdWHISAEbc7lqCnZXfs7xW9aXAjT5PSSROIRLBZTp1NTBRaLgd1uDjq4w223XcfBg6WsWLGcdeteJTQ01LvGSkYEqdkSbzCiI6udOJ3gcg1tWl9RIDvboKUFiopkSMBY5ektxbSfKHqGjuvDv6CMm4Hlqj+hnXoN+idPIhrKexzX7jJ4ekuxL82VSL4StLdDS8vQdfeee25j1qy5rFixipYWmXx1LCI1W+IN/MJZbW8XuFza4AeegKrCpEmCo0cVKiulwzrWqGlxsuFQTe9ppPpj0FqPmrEIRVVRE6aixKRjFGzqcZgAPj1UQ22L01cmSyRfCVpaBPX1Q9dcRVF44IHfEBoazXXX/QBdVngZU0jNlngLv3BWQ0MNIiOH91mLBXJyDI4eVTh61LN2SUaWdXvKBz+oG6LuSK9tiqLw5hDPI5FIBiY2FqZMGV74lcWi8be/raW5uZHrr/8xQlZ5GTNIzZZ4C79wVuvqBHV1wzfFaoW0NIPDh1UaGjxomGREOVjZ3GsFKQBhcRAQgrHnHYThwijbgyg/AK7evfF2l0F+VbMPrJVIvjpUVkJBwfA1OyDAzjPPPMW+fZ9z991/8KBlkpFEarbEW4x4UQAATRPYTjIvcHAwzJhhsHevSlra8EdqJf5Dk9PV53ZFtWBZ+AP0Lf/EtfsdlKjxKONzQOv7cW5q7/s8EolkeNhsZkaWkyEsLIQXX3yeiy++iJCQKG677Tsesk4yUkjNlniLQZ3VqKghLNEfJmFhFmJjA4mJcX8FYH/HBgRAYSGkpJjpsPyZobTXX/FmG6JD+6gQ8SVKxDgsF/yw69+ut3+Hkn5aP+dxDGinvA/+wVhogz/gC81uaWnHatWHfM9OPD4mJoS33/4P5557LpMmJfHtb1/pSTM9zlh4RqVm+weyDUNjUGe1uroJw/BuTFF5uZOysnYqKxvdOj4mJqTfY1UVIiPho49Upk0zutJj+RsDtWG04O02JIfYsWlKn9NKorYUQuNAGBj7cxGt9Wjp83sdZ7eojAux9WunvA/+gTfaoKqKTxw3f8MXmv3FF02UlLSSmur+PevvHkdERPD008+zYsXXgQCWLVvoQUs9h/ydDY7UbPeQbeibgTTbL8IAgoMNwsI8t5o/MhIaGgwOHlTJyjK6KqlIRhcXZsbx6IaiPvcZBZsw8j8BQ0eJnYhl0S0oWu+KEkIILsqM87KlEslXi5gYAM9VZJkxYyoPP/wUa9Z8i+jofzB//hyPnVviO6RmS7yFXzirbW0Cp9OzqacmTICyMsHOnSozZ0qHdTQSGWhjfmokufnVvVKhaDmXo+VcPuDnFWBBaiQRgScZEC2RSHrQ1DS81FUDce658/jtbx/iu9/9Js8++wqzZk326Pkl3kdqtsRb+EU2gOEUBXCHxERBYKCgoEBBZkcZnaw6JQW7ZXiPqd2isuqUFA9bJJFI2tuhudnzmr1s2XncdNOdXHvtCoqLe6c1kvg/UrMl3sAvnNWwMIPISO+YMmWKwGqF3bulwzoayYwP4aaz0ggYovhZVZX/Nz2NCaGjP4hdIvE3EhJg8mTvCOp1113F1Vd/m6uuWkFFRY1XriHxHsPVbJuqcuXkNMYFSs2W9MYvnNXaWkFdnXfOrSgwfrxACDh8WFa5Go1cPjOxS/wGu4MKEGBR+dbMNKyHU/jgA5WSEoVDhxTa231hrUQy9jlyBA4e9N7r47bbfsDpp5/HypUraWyUOTdHG8PR7O+fmkZ0bTLr1mkUFyscOKDQ1OQLayWjAb9wVq1WQUCA9xxJVYWsLEFzs8LBg9JhHY1cPjORR6+cydkTo7BpCja156Nrt6jYNIWzJ0bx6JUzuea0ROLjDYqKNEpLFWpqFGRlR4nEMzgcguBg705V/eEPd5CWNpmrr/42TmeHV68l8Ty9NFsbWLOvnpdIcrKgrs50VKurVTnAIOnCLxZYWSwGdrt3nUhVhYkTzaIB5eWCOLnYcNQxLT6EPyzL5EiVk8feq0SENdLU7iLYbmFidBAXZcb1CMzPzjYIDYX8fIW5c3W/TWMmkYw2HA4ICfGus6ooCmvX/pEVK77F6tU38cQTf0ZV/WJ8ReImnZpd2+LkwdcqMcIaaenoX7PnzDEXQ5eWKlgsgqioETRe4lf4hbPa2AhNTd4XIbsdsrIMdu5UMQyDhASvX1LiYYSAI4UBTHKN54pzXNjtAx2toChw1lk6Bw9qTJqky6wQHqCmxcm6PeUcrGymyeki2GZhUkzvF49k7FJRoVBZ6f0fk9Vq4ZlnHuXyy5dz88138dBD96AocnZstFFfYWdc03iuWOIiIqL/4wzDXGy9YIHOgQMqNTXIapQeYCxotl84q0FBOuHhvhEgqxUmTzY4cEAlONggRMZyjypcLigtVVFVQXs7Azqr0dGCoCBBcDCkpOjs2KEQGOi9hSFjnT3HGnl6SzEbDpmLXron/v4wX+XRDUXMT41k1SkpZMbLH9ZYJj5e4HB4Ls/qQAQFBfKPf/ydSy65hN/9bi0//ekan1xX4jmKixU0DerrFSIi+tffoCCYOVMnNBQSEw0OH1a+nBkzkH2UoTOWNNsv5lRaW6GtzXdPYmgoTJ1q8PnnKg0NPrus5CRpbobPPlOxWgXh4Qy6KE/TILhbMYyJE83ckC5ZdnrIvLyzjNUv7SQ3vxqnLnpVqGl3GTh1QW5+Natf2snLO8tGyFKJL6ivF1RX+06zo6PDeemlF/j3v//BX/7ynM+uKzk5dB22bVPRddMRbW9n0LUDoaHH/05KEigKNDUhs/kMkbGm2X4xsqrrAsPwbbcpOBgmTTIoLFTJyDAGmU6W+AONjQpBQVBSAgkJBgcPasTG6gT0X466B8HBMHeuwcaNKiEhZkjISDJapmZe3lnGQ7mFtLkG/74E0OYyeCi3EDAXWcDoaavEPdrbFdrbfavZiYnxPPPMC6xYcSkJCZFcdtkSn15fMnRaWiAoSHDsmEpIiEFZmUJ0NERFued5WiymZh84oHDsmMIZZ4ysZsPo0LKxqNl+4ayGhAiPllt1l5gYc3HX1q0a8+bpWHtXfpP4EfHxgvh4wdGjGllZAqt1ePcsO9uguFihocF8BqqrzfCQ7j16bzKapmb2HGt0W/S60yl+ARaV3ILqQdt6y/lTSQyQAcWjhcREQViY74e6MjPTefLJf/DNb64gJCSM887rXVte4j+EhEBGhqC5WRAeLkhOHt4zM3GiQNehoQGioszZ2Lo6hYQE3z2Do0W3x6pm+4WzWlcnaGgYmYiEiAhITTV7blOnCrkAZxQQFycIDTUzPAyHgAAzbnX9epUDB6C1VSMqymDaNO8LX2ePt91l9CpHCObUDEBufjWbimq56ay0rp7uSPD0lmJadr+HUbARUXsEJXUulgXf6tpvHPwYffd/obUBJXYi2vxvogSGA6b4/ep/BxCCQdu6+fAm1pyZOqJtlbhPSYlCXZ3K5BGoiDp37kzuv/9RbrnlOp599iVmzcr0vRGSIREeLoiNFcOewVRV0+ndu1dh505wOFTa2xUSEnyTj3A06fbTW4ppdxno+z5ADFG3/Vmz/SJm1Wo1vJpndTCSkswYyK1bVYyRn2WQDIDLZcaieiKDTU6OQW0ttLSYVc68fe+7T80M5hZ3n5oZqViimhan2bt2hKNOX4o6cUGP/cax/eh5r2FZeD2Wqx5ECY5G//jxnsf0I3rdEUBrhz6ibZUMjeBgY0RGVjtZsuQMfvnL33HNNd/g4MGiEbND4h6trYpHUgdOm2bGsFZWmuEFHT5IvzuadLtTswWgDFO3/VWz/WJkVVUFVuvILvVLSjIf/Px8hUmThFx56Kc0NECNByowtrbC9u0a48bBpk1mlavQUBdxcT1/pp6K2+mcmmne/V6/vYZxyZAAACAASURBVN1O9J3rMHa+gbboZtoSp/FQbiHT4kKY5uOppXV7ygFQx8827ao+DC3Orv2idBfq+Dko4WbPWp3xNVwv/wjRWIESEjvk63WK/Ei0VTI0bDbcjhX3FpdffhHl5dVcffVVvPbamyQmDv2Zk3gfIcxsAFlZJ3+ebdtUwsKgqkph/XqFgABBRoZ3NBtM3b7vkSdwHvzUbc1WE6eNmJZ1ajb4Rrd92U6/cFabmwUtLSPvHU6YYE4z7N6tMn26HGL1RywWM/XYyeJwQHa2Tmws6LpOfr7K/v1mDKuqej4+qXNqRnGEo0xfiijbi9CdvY4TjRUYh7eBI6xrW7vL4OktxfxhmW+nOw9WNvdaQdqLHkt0zb9FbRkERqBvfh5x9Atob4aQGLTZl6ImTceoLMTY8Tqi+jAoKkr8ZLS5y1ECw0esrZKhUVGh+iQ39mBcf/0qamqquPLKFaxb9yrh4T4KPJe4jRCQkXHyqacUBWbMMAgLg4gIHU3TKChQSE0VBAR4J6b06S3F6PZQ1CFqNoyMbrul2eBR3W4PDPdJO0debTAXWIWH+4UpTJkisFoFJSUj7zxLenPsmEJrq2fuTVAQBAaapXgvvNB0XMvKFI+n/Og+NaOOn42akg32oD6P1Tf/E23210E93o8UwKeHaqht6S2U3qTJOXCOLyUxE+PwNkRtKcLlxNi5DlBAd4JhoARGYLngdiwrHkLLvgQ99zFEUxU4m1EnnYHlst9i+fpvwRKAvuEZYOTaKhka48YZjB/vHx36O+64jZycU1i5chUtLW0jbY7kBGpqoL7eM+ey281FW8nJsHSpzvTpgqIi1Stpmjp1WxmGZsPIaNlgmg2e121ftdMvPMSmJuHTPKsDoWkwaZLg6FGFw4f9wybJcXTdrEvuaSwWmDpVsKHyiMfjk7pPzQyEUbQNVAvquOm99rkMwS//u98rglBdbXYCDKNnhzvYNvDEi5o4DXXmMlwf/RXXKz+F4Giw2iEwAsVqR5u1DCU4GkVRUcfNgOBoRPVh1KTpqBNyUGwOFIsdbepCREV+13kVReFNN78zychQVQWVlf6hj4qicP/9vyYiIppvfvP7uFy+WXQjcQ+XyzPxqidiscD48YJdraVeiSl1R7cH0mwA3RC8lOf5mM6mJjhyRMHpHJpmg3d02xea7RdhAIYhEMI/hA9Mh3XmTIP9+xXq6iA8fKQtknTicHiv/N6eY43c/2jf8UkDTV13j9tJCQ7pWvF68KBKaqrh1tSM6Ggzg97Pu7nP/YaATYdrufDxzR5Pj6IosHu3SkyMQVGRSmioQWCgQpw9CJumDGi7NnUh2tSFZhsayjE+/09XLFSP9rU2QEN5n/uM8oM9tre7DPKrmj3QMom36OgAXfeLsQ4ANE3j8cfXsnz5Stas+RF/+csfZVlWP0FVBbFeCif2hGZPCA1BVc1R20OHFEJCICZGDKrbg2k2gC7gqS3F5Fc3e1SzbTbYv1+lslJw7BhYLAqBgYJIdXDNBs/rti802y/UJjjYIDTUv4TFbjdDAnbs0KitHWlrJJ3s3u29R7Z7fNKJKygHmrqG4/FJRUUKn3yi8vnnCgcPKqgqNLQNPjVj7HwTNe1UlODo/o8ReLziSGMj7Nun0tgIW7ZYqKhQUFWFjAyDb5wWB4AwdITeAcIAYSD0jq5tovYIQghEUzX6xn+gTj0X5YTpMmG40D9+AjX9NJSwhJ77aksxdq1DnXN5j+1N7bLMmD+TkCAYN84/wgA6CQiw8/e/P8Xevbv5+c9/P9LmSL7k4EGV1lbvnNsTml1To5Cbq/HFF7Bzp4aum4utGwfRIHc0G0zd9qRmO51w4IBKVZX5Pjx0SKWtDdLTDa45Pa7rOF/rtrc12y9GVuvr8cuyp3Y75OToFBYq2GyCoCBzFbnd7pnUSZKhIQSkpRnYvFA8o3t8kkLvFZRqUs9pHm3qQlzv/PG4bZhxOzOcHZTmB9DertDRISgu1jAiB/+ZGUe/gJZajP0fmRvaG9HXP4bIWoyWtbjHsSdWHPn+oik99jc2mrG4feUMbmgwCyBs365isZhZMBwOSE4WJCToTJhgEBnJl9+xjfmpkbz/8t8wdq3rOoercDPqjAtRpy3C9fET0FQJlgDUifNRZ13c01ZhoH/yFGgW1Hkreu5rqMD13sNoc69CjZvUY1+w3S+kSdIPJSUqbW0qkyYNfqwvCQ0N4cUXn+fiiy9i7doobrzxOoqKSjAMQVpaykib95UkLk4QFeX583pKs8+PdLJjh4PNm63oOuzZY2HRIgObMrAGeVKzW1vNGa6+Mmw0NZmavW+fQnW1yowZOk6n6Zw6nQpJSYLoaPFlqIWp2bn51ei7/uNT3fa2ZvvFG8FmEwQG+qf3FxwMqamCLVs0MjN1Dh9WmTBBEBMjCxX7mpaWwetKDxd340o7OXHqGkAIhe01x4hXJxARIbBY4MwzDcJag9heZU7NCEPv6ul29nZRVCzn3QrieONc/7kXLecKlKT+8710it+CqXEk2E3PtK4Otm7VOPtsHU0zv69DhxRsNnOhw7FjKvPn60yaZBARYYrguHGC/fsVdB3i43teY9UpKWwquoS2Wcv6tMG67K5+7RNCoG/4O7Q2oJ27BqX7orGmalzvPog642uo6af1+JzdojIxuu/FDBL/ICxMJzDQv0ZWO4mLi+Kf/3yRiy9eRk1NPc888zDZ2afz738/P9KmfSWpqVFIT/f8+9JTmv3BoXJCxQRCQ81821OnCk491eDA1iA+PazQ3uHyqmZ3dMDGjRrTpx8vHV5aauamtdth506VOXMMkpIEEyfqBAVBdLRBdTXs36+QmGi+azoxNbsWMWsZmo902xea7RfOKhhomn+FAXQnJATS03XeeENj8mSBokhHdSRobOTLeuSe//7dTvnB8SkQbeH1PbZ3GAaBiU1MSxSccopOebmCEHBhZhyPbigCwOint6vNWtaj4giqBrZAFGsARuFm9E3PdjPAAL0Dy9d+TnvUeP7vo3zuOX8KJSUKVVVm7sHcXBVVVZg+Xae2ViElxWDmTJg1yxTXE0vLpqX1FLxOMuNDuOmstGGV7zM2Pwf1R9HOuwXFcnw4XLTU4vrf/ahTF6JNOav39ysEF2XG9dou8R80DQzDfzU7NTWZNWtu5mc/W4OqquTlfYzL5cLS10Mu8RpOJzQ0KF7JW+4pzbZENTFvnOkMWq1QUWF23Dt121ua/asLplBdbWagCQgQXbNdGRmCigqFiAizPG1KSt8jNOHhMG+e0WsG7WQ0G4an277QbL/45ba2Co+lI/IGNTXmtNf48VBYqBIQAJGRhgwF8DE2G0yY4J3RHHdSfsDAU9dgxjnNX6gTGQmxsZ1CenxqRhugt3tiDlY1cRoAato81LR5XccZ+RvQd62DyBQE8MG+Ss4KSuNIgYPqajObharCggU64eEQEzP4d2a19r+vs5zeQOUGu9qAOZ2lN1ZjHFgPqgXXv37YtV87dSWisQKaqjB2vomx883jNnxjLQqwIDVyyMm7Jb6lqkrF5cdhxZ9+upW77rodTdPQdR1d19myJY/58+eOtGlfKYSAKVO8Mx3mSc3OzDGn0lXVnEkFiAz8Urf1ZQhPa/b+Sr4Wl8bh/QGUlSkkJEBQkEFWlkFCAiQmDu6ED1QafjiabQhz5HSoum37xlqfaLZfOKtBQQbh4f7rrAYGmrF9iiJoaFDJy1PJyDAI6bawz5NVMyR9U1KiEhkp8MbIqjspPwaauu4kLNDSZ7aCzqmZgXq6/VUcORGjYIMZ9N5tuGJHfTnnZyejaQoul5kKLsiDszKXz0xkWlwIT28p5tNDNSiK0lUnGsxpICEEC1IjOTM9it+9l0/7/3us3/NpMy/qc7vdorLqFBlb6O8kJxsYflybOiNjEtdccwOvvvp3WlpaaG1t4tln/9nDWZWa7X3Ky6GuTiE52X81OyTA0m1goSeD6fawNVvAp2XlLJmezOTJZs7vsjKFsDA8Ngo9ZM1+P5/24CisQ9RtX2m2XzirLS34RQWr/ggIMKtbAYSE6OzerVBQoDBzpmBvueerZkj6RtMEoaHeCcGYFBPEBwf7j0+irWHAqWsYOG7nZKdmOhFN1YiKg2jzV3Vtc+oGDWoTM2aYjrzLZeYu9vTI/7T4EP6wLJPC6mYeyi1k/7FWDEXHYdWYEOng5rPSSI0y279nv+C1wwW4hPttDbCo3HRWmiy1OgooLwddV5g4caQt6ZvIyHB+97u7+M1v7uB///uIX/3qLj777DOcTjhYIzXbVyiK6YB5A29rNnhGt/vT7HqliWnTvqweJSA+Xgw4wzUcTtTsg+WtdAidQFtvzS49KnhmVwEu/FOz/cJZFULgJ1m0BiUyEs44wywa8FJeGX/+pP9h9s5eTG5+NZuKarnprLSu4XnJ0LFY6DGa7UkGi09CUfqduu5ksLidoUzN9IdRuBEldhJKSM90Kd3Thlgs3skN3F85w9rWDqpbnKx8djvzkiNZGJ9CupHEFRPhlUMFON2Yhgqwaqw5M1X+PkYJ5qCq/w4wdKJpGkuWnMuSJedSXa3wr7wj/HWz1GxfIQRfzoZ5Hl9oNpy8bruj2YrSex2BJ+hPs+vajmv2aeMjWZySQmxDEstS4D9HCnDq/qfZfuGsBgQYhIT4v/B1oiiwofIIf/7Evd7WiWkrpPgNHcOA/fs1pkzxTqCcO/FJ/U1dA27HWp44NeMyBMYQ1M8o2IQ2fUmv7d5OG/LyzrIBxbrzJf9JUTUbi2q5ako6t34tgcXHgt2ahrrlgqldq2Ml/k98vPDKohlv8mGp6ahKzfYd+fkK2dnecVZ9pdnQU7c/yq8eksPq75q9vrCaTw/VckFMOr9cmcDFfqrZfuGsNjUJGhpGj/LtOdbY77SAaCjH9cbdKOPnYDnj2z32da+acVaMnF4aCoYBWVm6V1+Q7sSV9sdQ4nY6p2ZqW5z88r/72XS41i2H1ajIh9Y6lPFzemwP8HLakE7Rc/cl78Lg5YICxu0UXD4zsautb+4pJ7+qmaZ2F8F2CxOjj8cHxsSEUFnZ6LU2SDzL4cMKiqKQljbSlrjHQJoN/eu21OyTY/x44ZURw058pdlwXLf/+mkRT28pQReDi/ao0Wxh8F51AVl+rNl+4ayaCfdHj7P69JbiHr2N7uibn0eJntDvZzurZpw1XfbUh0JdHV6rgtLJcOOThhu3ExFo467FU7jo8c0D5mBVVLP3ahRsREmZjWLtmTlagNfShuw51sh9j/RdzhDM2tj6zjeguRaCItGyL0FNyaa920t+WnwIEYE2/t/cZK/YKPE9kZEGFsvoCN2CgTUbBtZtqdnDw+WC8nLv5FjtxNeaDXBldiL/2FaCruO3mv1QbiHNu9/rSqvljm63p2T7tWb7hdoYhkBR/MKUQemsmtHXz884tMXMsxY/td/Pd1bNqG5q95qNY4mmJjN1WEWFQlubGQPlTS6fmchNZ6Vh19RBI/IUjovecKcJO6eyFMwcrK7nrsfY/V9E4Wbz713/ATBL5BVt67WiVQEWTonx2urlgcoZipZa9E+eRMu5AsuKh9HmfB394yfMetIcf8lLxh5CeK9Ah6cZSLNhcN2Wmj00Ojrg2DGF2lpTvw3Du7otNbsnnR0zxRE+ZN32Z832i5HV9nbjy2Tv/k9/VTOEsxV9xxtYzr8N4+DHA55DURRe3l7KZRmx3jBxTKHrsH27RnOzQNMUNm0SZGQYXllA1Mni9EQaDoWyVznMxqLecTsWRUUImJcSwfdOTxlW71wIaG42y58uiBjPRsvAFUcUzYp1xUO9ttstKj842ztLsgcrZyiaa8EW2FXWUBk3A91iRzRVojhCu17ytS1OmQpojFFTo46akdWBKh25q9tSs4fG7t0qqiqor1fYuFElJUV4JX1VJ8syEmkpDeWz1sNsO9K/ZmfHR3LjOcnDXr3e0mLO8J0eMZ6Nmv9qtqD/tFoD6bZwhPqtZvuFsxoYKPw6z2p3+quaYex4HXXS6ShBEYOeo91lsO9oI3hB+MZa7sCwMJg82SA3VyMpySA6WngtFQqYIwG5uRqRhHHfskzqWnvH7YSLYOp3JLI4yUJGnPtTT0LAunUa4eFmud68PIWmJpVLLgnGFTr0qSybpnLj6WnMGBfuldihwcoZKlETUMLiMUp2oCTNQJTuBM2CEj7u+DGKwpt7yv1qOkly8owfr/dZ8cwfGajSkbu67U3NhrGl21YrzJ6tk5urYbWamUni4rznqOo6bNigodaG8ZtLMulQe2t2giOIms/GMSvMQnrE0KYENm1SqalRyMgw2L1b4dAhlcWLg7n57OFp9upTR06zYXDd9lfN9gu5aW727zyr3emraoaoKcE4+gWWC+90+zwNbR3Hz9lklhGNihr+D7q/FBUw+nMHGoZZts9qNaszeesapaUKDQ1QUKCQmWkKUF9xO/X18F6rheLydra9X8bRtmZaXYO/YNrazKojRUUKhYUqdrtgwQKdmBi4PGZoFUfsFpXlU9IJKU9i1y6IjTWzVHgyt+pg5QwVVUVNOw394ydB7wBVQzvreyhWe9cx7S6D/Kpmzxkl8QuOHFGx21UmTBhpSwanv0pHQ9Xt7prd1maWEe2sejRcxqpuqyq0tSk4HAZTphhe69hUVipUVkJhoUJoqHkv+tLsjg54t0WlrQ32FnawrfoYxQ3udQza26G2FjZsUDEMmDnTYOJEmKwOXbOvnZ1GRNU4tm6FmBhwOHyr2TC4bvurZvuFs6ooAlUdHc5qX1UzjGP7obka179/Ym5wtYMw6FhXhrUfITTarKxfr5KQIDh6VCUuziAqang2uZuiYrTmDoyONtPkTJ3qvd55U5MZZ1VXBykpgqSk/q91uKmRt5tK2FNTjQJ0iMFfMIYBJSUKhgH5+SqTJxvMmWP0WHwwlIojq05JYWJkCG++qfCf/8CsWSp1dQrTphlulepz6zsZpJyhUbYX/bN/o51/G0pUCqK6GP3DP6OcexNK5PGXRfd8gpKxgap6vuiEt+iv0tFQdbu44DDPPNPB9OlT0XXzxR4dPfzf2ljW7eBg8xmZNEl4zVHt6IDSUqitVQkOFqSnC2z9DEJbLCAi6nnzixL2/bcaUHoULOlPt0tKFDo64OhRBVWFs882mDnzeKn1oWr2tPgQPv4Y3noLMjNVFMUceZ4xwzPV4NwpQeuObvujZvuFs2q3GwQHjw5ntbNqRvfeizr5DNTU42X8jD3/QzRVo516dZ/nsGkqoSKEbds0xo0TGIbA4TB763Z73+XWqqsVIiJ6vyCGmqJiNOYOtNkgI8OcOvcGhmGO2ubkGLz6qoXx4w1KS1UmTNAJ6LmIk5d3lvGnjwr7TZrc3wumtFTho480QkIEixbpFBSYtdVPvJ/d01oNlDakk7lzdQoLoboaUlONfssGDofByhmK2lKUuEmoX66iVqInYESnYhz9Aq2bs+rtfIIS3xMTI7Dbvbza0UP0pdkwNN22KBDobOf55/9Ga2sR8fGTSE3NQtezmDEjg8DAgF6feffdT5k2bRJJSb1DB8a6blssZqd/4kTvPSNOJ2RnCz76SBAZqVBfD/X1fc9QPre5jP/bVIhLdOp2z2P60u0L0hJ5/30NVYW5cw2OHjUXjWknpBYdqmZnZZkjzTU15u/Ik4MwbpWgdUO3/VGz/cKipiZBY6P/OauNjabjGBBgLoSxWGB6cDxQ1OM4xWIHy/GpTyx20KwoAf1N2wh+unwch/d3UF+vUFxs9toKChQqKlSSkgxCQ8FuF10LiQ4eVIiMhMmTjz/Yg+UO7I+2E9IK+SPdY7ga21xYsXBwq3diuFpazEVcZjoeg5wcg9paevXSu0ZC9KG9YFqaIaZ+HGlpBmlpgrg4QUqKGNCxdDdtSGSk6agWFSns3aswYYLnlmgPVs5QiRqPsfttRE0JSmQyoroYUZ6POuXsrnMMVs5QMjopLlZwOFRSU0fakp60tJgjbiEhpmarKmSHxSNEUa9jh6Lbqqrw5E8vp/jKi6moaGPTpr2Ul3/O3/72HEVFhYwbl8qMGVnMmDGdnJxpBAUF8Otf3wFYefzxtUyePKXrXGNVt0+Mu7UYFg7sDGJZlnfibj/7TCU5WVBRobJkiQtFoc9R3Jd3lvHXLYV0uFH6uVO3/5RbyIEDCjNjkhg/3nS6q6sVAgNPXrNDQ82R56Yms9BNerpr2LOqJ9K9Y9ZvWq1BdNtfNdsvnFV/zbNaUqJQVaVisQi2bdNITDQ45xyYPyGS3IL+q1j0tzoQjlfNiA+3o6U5KSoy89HNmWOebfJknZYWs4dYVKQSGGjGyxw7pqIoBjt3mg6rw3E8RYW+74M+86kJ3WWmpKg+DM3VaOffhhpvimZnioo/LMv04Dd28gwUw7Wx1DsxXA4HhIQYHDqkEhAAX3yhMH58z1HswXLXiboy9E//hmisBECJTEE7ZTlt4Yk8trWQP18awqyU4/YGBXmmN22zQXQ0zJqlU1JiCqDDYXayjh1TmDBh+NdZMjWOv37afzlDbdYyxMyLcOX+FVobICAEdfoS1MTjz5Q75Qwlo4/YWIOAAP8bWa2rU9i3TyUiQrBtm/kDXrZMYX5qJOsH0GzoX7c7NTs6xI5IdhIcbKe5OYfvfjcbqxVaWtrYtWsfeXm7efbZf3HffQcJDg7nyJEygoICWblyFXff/TuWLDHr0z+9pZiW3e9hDFGzwT91ezDNfmyjd+Juo6PNWFW7XVBQoJKSYhAc3Nu2/vJE96fZSngi7S6Dt44WcMmVwV0dg4FCw4aCpplT/1OmGNTXG+i6uQ4iLAwOHFCYOHH4ITYXZpqaDQxbt/1Vs/3CWTUMgRD+56wGBgoKChTi4iAuzuDUUw0iI2HVvBQ2HfZM1YwJE0SPuCer1Xxow8LM0TfDgH37TOe1tFThwAELRUUupsxs70pRoTjCUaYvRZTtRejOHtdTYieiZpyLvv7RHtv9Ma3QSMZwdXYOFiwwq2TZ7T33d89d1+d3HRiOdtb3ICgKhMDY/yGu9Y9jXXYXTt3g+R3FzErx/AvGZoPZs6GyElJSoKgI3ntPIylJ4HIpjB8//KpfFpeNycFR7J01QDnDqeegTT2nz31DKWcoGV04nYpfZgMIDRUUF5vphUJDBVOnmqEx35qXwmYPaXZEBMyZczwbQmBgAKeeOotTT50FQHu7k4ceeowdOzbQ2tpCVdVRrrtuBd///k9YtXq16dR9mQNzKJoN/qfbI6nZug579mjk5OiAIDCw9zHd80QPRbMBnF7sGHRqdkyM6ai++66FqCgDUEhK0gka5sBmsMXGxKAo9jVWoQ2QVqs/3fZnzR5UbqKiggc75KTRdQWHI5iYIZSzG8qxQ6WhwQwB6OiAjAxzSmnmTFOkAM6OCeGOZie/eesLWjvcFz+HVeXnSzO6KqF0tiEmZuDPHT0K6emQmgrz50N0tJ1/bDuGoiiA6DefmqJZ0KYtMvf1UXRBVRQ+PFzH985M79rmcpn/nRir2R+eug/Pbiri4fVDi+F6eH0hIcF2Vp464aSuHRUVQkcHTJ1qfr8hJzSpqqmdjUW1A+auU2yBYDPVUggDFBUaK7rs3VBUi+qwERV8ghfsIbo/S1VV5grWuDhzysnde3kimgaXTpnCgW21dIihhxcEWDVuuWCq28+IN3/TXyV8odmGEYSq2oZ8z7x1j9vazOe+ocH8HQcFmXo5YYI5yxAb61vNbm6ux+FwEB4ezIQJC5k4cSLnn38eHxyqQ1GUYWs29NZtIUznvC9nrS/GgmbHxIRgGDB+PGRnmx31E+nU7f7yRA+k2Z02e1O3uz9LtbVQUmLew9BQM7xrOLS3w/IZU/j1hrGn2YM6q9XVTRjuFC4/Cex2HWh1O++Yt2rSdqao+PxzjYwMg0mTBCkpsG2bSkuLgavbArkL0qNoPDONP+UW4nQzbcWaM9O4ID2KysrGIbUhLMx8oG2244J0qLZmwPKB7tDmMthRVENlRmxXKdPNmzVSUszYysHw1H3Yc6yRX//ni4HLwx39An3z89BcgxKdirbgW7QGR/Hr/3xBcpBt2DFcnW1oaNBYuFCnrc188XXn71tLEG6WYOn4501frioWqCf0ap9eX+CV3HXd78OWLSptbQpNTYJNmzTa2nRmzer5nAyW01EIKC+Hf/3Lgq7bWZaSxhslBXQYQytnuObMVBLsmlvPiDd+06qq+MRx8zd8odkREY04HPYh3TNv3OPOKdTduzWiogymTRMkJnamGTKoqjp+bKdmDyXV0HA1+xvf+AZXXHElGRlpaN1W5Lzx1j6P6faR9FiEgM8/N53anJzBzzuWNPvoUZWsLEFAgKCysvdx7ur2QJoN3tHt7vehoMDM3Wq3Cz76SKOy0uD88/UeoQCDabZhmO+tl1/WOHrUzpLxabx9tMCtON1O/F2z/WIip7nZGNE8q7puxqfu2aNy2mk655yjd634s9vhlFMMrNben7t8ZiIxWigv7ylm+7Fqt9JWDIcT43DAvRQV7lBR62L3boXt21XCw82QhIYGQWurGZKg672nxIdLaalCZGTv6ZrBpthFWyP6R4+gnfb/UJJnYuS9jr7+MSxLfzqkGK6+fvCzJkQyMzSCefOUfnuz7uSu68S64iFER7tZEzr4+Al9lbtuzhwDp9OcGbBaFUpLYeJE8xlyJ6djRngU5yelYGkIpaBAZfZsg2XnJpCwBx7/rMDtjtloSrMjGTqHD6tERKh9jmj5AsMwndRPP9WYOdNg/vyeRQrmzu1fs+MsFp7cWMTB5navafaUKX2vPPOUbpfXuHj1VfMlNWGCwOUyv4/QUNNpCQjoO6vMkK9TrvRY6NuJrzQbeut2dGgA8QF2ZiQmkJ7evwvjrm73p9ngG91OSxMkJOgIAS6Xmev72DFITHRPs7OiojgjKoXkwFB27VKJjxesPjeB5P3wxPaxo9l+4awqsUv28gAAIABJREFUillK09cYhrmYpq7OrE5x/vl6nwLX1zYwg7sPbw/njgtCsIW0u5W2wlO4k6LCHcKDLAQEmE6p06lSV2dQWqoRFGTQ3g4FBRqnn+5i+3YNm02QmWmwd69KaqqgqQmKilQmTTKorDQX9kREmEUegoN7i2VlpcLRowpTpxo4HObKTbfKwxXnoYQnok7IAUCdeRGul25F1B+FsIRBY7gG+sF/lF+FIQTzJ0SyytL3AoCh5pxTrHbUKWfievE2lIvvRnGEDus8w0HTzPvgcMCiRTrl5VBcrLK3o9St2LJd1VXsranhjOCJXHZZAtnZgpAQ+OaCBOamBw8pn6Bk7GK3C6zWkVlgVVKicPCgSmamzrnn6jgcvY/pT7OrquDzXBffnTWRjFnBPtVs8JxuhzksqLpZTKa9XZCfr2KzmYuAtm7VyMrSqalRqKpSOO00nd27VSIjBZmZsGuXyvjxpr67XBAfb2p2pyZ3p7kZvvhCJTvbwG43nWBfaDYMrNum3hQxv6j/hVs1je7rbX+aDd7XbUU5PmO6cKFOfb3ZGVx/tJS/fDq4ZudVVPF5ZQ1nhkzk3HMTyc42iImBVTEJnDJx7Gi2XzirVqvA4fCds+pymT9Ai0UQGgrp6caQ4vp03RS9ffvMvGttbRAX517aCk/RX+7AoWC3qExLDGLiREFiot41nbZkid4Vt5mVZf5Qzz5bR9dNMUtP70ytZR7jckFZmSmWbW2CHTtUMjMNyspUamsVFixwsW2byuHDKmlpBi+9ZCEpSTB3rs4rXwxeHk7UlaFEHP9uFasdQmLM7WEJA5aHG2wBQGe8VW5BNZsO970AQDOG8TMRAnQntNTBl8Ln69x1imK+iD4+Vjqk2LIOYfBxcz5JTYIzQxK69g01n6Bk7BIV1XvltTcRAg4dUrqqRs2erfca7Rvs8zU1UFioU1TUQnZ2PBGBqs9LSnpKt7OSg1g2Q6e9HbZvV1m0yNU1yn3xxaZmT5ggaG83ndBJkww0zdRvVTW/j8pK8/sMDDTYtEkjJkYQEiLYs0fjtNNcHDqksmePwqRJgtdesxAQIDjzTJ3XD3hXs+HkF241N0N7Uz89ln6N7q3Z4HvdDguD/YbpqA5Fs9c35RPRKlgcNzY1e0Sd1Q8++JQjR/KpqKjh5ZffYs+e/Xz965dgsw3xIXOTjg4zP6CmmaO5aWliWFPc+fkKpaUqDodgxgyD0FDfjzBcmBnHoxuKAPrPp6Zq5t+dGC7z36oFRVF6pKgIDOws/Wb0OX1ktR4frUhKMv8fEwNWq/ljOuWU4z+qpCQzsDslxXRwrVazRJ3Vao782WymI9XaqrC/fPCpGuFqR7H37PUpVgd0tAOmcO0/1nuqZjiJt/+UW0hjg8I1pyXQ0WGmf4pQgrEolbhE/7nrxLH9KPZgiBgHrnaMHa+bwfvhpnCMVO66PccaeejD/TR/+izi6BfQ3gwhMWizL0VNmo5oqsL1ys965JtUsy6AGRfy0sECFh0L7tXjdjefoGTsUVfXRltbE1u31hEa2ordrhEREUZAgHdeJUJAcTEIodDcDOPHG10LXYdCebnCnj0K7e3VZGcHkZyscWJieF/QqdvD1Ww4nlrIbjcHDGbNMnC5lF7t0bTjI3ZxX2YiCg83k9Kbf4uuzyxefHwxTmqqC4sFHA4DIVQ0DQICBJpmrutwZ3rdHc3ee6QZ5vb+7LB0+6NCnE4zzKO62tTt5JAg9jSodOgdw9JsGBndPhnNfqO4gIvKx6Zmj6iz+vDDD7N587vous4TT/wRECxefD42W5hHr9PRYebfO3pUweWC6dP7jmdyl/R0QUCAzrp1VnJydAoLVebM8Uy5NHeJDLTx/9l77/i4qjv9/33unaIy6sWSrGYVW1azbLn3ArbBYJoDIQkJCWGXbJZkdwn5bjakbXazaWST3QV+EFoKEFowhF5sjAHbckEukmVbkiXZ6lbvmrn3/P64li1ZbSSNRiN73q8XL2B0751zZ+Y+99xzPud5ls8KZVdxA9oIfmqO7T+EjgYAtPd/B4Dp5p8hbOGDLCqEgBkzXCfginIxoSkoCHRdEB+vs2iRA7PZ+Jt2YPQpFmGygr1rwGvS3gX9MujrWxwXarV6emB3QRu//biUzuF8UYe54Huyr+P3B0oI1gPoPBvIsWMmwmbGYARByGG960RwDI6854ynctWMCE/EdNW3EarxQ5sq77qn8yro6XUg/EJQN30H/EORlcfQdj2GOG/RAmD6/G8RysBoll7N8zwdvUwt1dVtvPLKpzQ1tWGxWCgp8eeOO1YRHR04+s5jQNeNkdCWFkFVlWD+fJ3ExPEfLyJCsnSp5MEHW1i9OpqTJxVmzhy/rdt46dPtD156asyajS18SGshY4TZdbrdd28MCjI6vFar5Oab9Qt/0/Ndo9m1TQ66ugzNlhKqqgRlra3D+6IOo9lq9nX0aDoPfVJKe0UQZw8H4+cnycyK5m2G94keTbNhanR7Ippt1y9fzZ7SzuoDD/wrN930IZrmACSf//xXCQlxXUdV1w0rk8OHVUJCdDIzdZfkWZtMRsduxQqNzEydhoapWRx25+J49pY1IUfwUzPf8l9Dvn6pd+BkYzbDsmWD40udqeESwTHoJXsu/L+090BbPSL44rRPT7uZhx82XUgbeTb/DL0j+aKeZ6gL3iF1/lpUwUa/bDIzNebNUyk9GsKB6oYRvev66rMGtZ+p8a7rqy3DbB3QZhGbjWYLRzaUI8ISht3f0zwdvUw9qalhJCcHU1ioY7HAvHnRLu+odnYaZVrd3cYK9+TkiXfEVBXa29tJSYG1a32pqnLv4EJ/DN2+ke4xaja4X7ezs/VBi7Vcpdmy18wTT5jw9YUlSzTq6hReaxrBF/U8Q2k2QK+us7O2nKsSgsjM1IiPN5FWE0rBCD7Rw2k2TI1uezV7eFzQdRs/CxfOJyOj78ei8L3v/T+XHFdKaG6Gt95SaWkxCsyzs8efCnEpum5cvDk5RsavK0cjx0JGVADfXpOEj2lsJ+ZzfuWfOwuq+2JrLyU1wh/L+cV1UteMKZp+0zVS1xDx85HNlejlB5GaHf3I64iQWESQMV1jEgoxvv40NQlOnRLsP+LgeMvFBQBK/HywOj+VI4HizkbmL+vi1ls1MjMl31wXj3WMn3Mf7r7B9PF6wdC1ZbKrFVprB9w4HC9/D/tL38XxydPI7ot2JH21ZV68AJhMCvPnz6ayso36+h4WLkwefScn6eqCXbsUTp5USE/XWbFCd5kTCUBFRRNXX20MhsTESLePqvYxnXS7Lw2vP67S7PgAf1pbjTKPAwdUKhvs7D/biBiHZvdR3tvAlls6WbJEEh0t+c61cdNKt72aPTxTvsDqRz/6d264YR2bN99MxGhOy05QVQXFxSopKRqrV2uDDN5dQU2NkekbF+e6HPbx0ldU7qx3oFlR+OYKz7Go6F97O1I8nLrmHrS85+DjJw3PvtV3X9hOCMm/3BSJ3mWnu1vwh7wqhJPTYo6XvwcCRHQ6au4tA3LB8+pqyEwx6nz6bjBjzfSeihtMH0PVlkndiHNUkpchgqKR9m7Ua/8NERoHPR1o+55F2/0Epqv/CXCf5ZaX6UNiYiTx8Vbi4iIJC5v4TFhbGxw6pJKQoJOdPb6a1NHo6HCQl9dNVpZn6N5YdBspsaieYy3kCs0G+MY1kVilg44OqK5WeLu8yqn3H0mzhRC8e+riwq2M6Oml217NHp4p76wuW5bLunU38cADD4z7GFIa6Q+trQKbDTIyNMLCXNjISwgMNOL2PIVt82JInxHglEXFqrAE9LOBnEsYGPM6VfSvvR1xij0mHeXGnw56XQArk0KJCLRAoBHdW/dxO/bRzKCtthEveIfUKWsZeMGP9cFgqr3rLvV0lFJH+/hJUE0oS24HQJh9EOGJxga+gahLbsfx4v1IezfCbAyFu8Nyy8v0wWJR2bx5GWFhE1t40tAAlZWCwEBISdEuLNycDNrbm1mxwg8fn8HTx1OFs7qdFmih88AR5l+/BCld4586EVyh2auSQ4gOMaapQ0PBbpecK2kfeeHWKJoNRp39pR216aTbXs0enintrPaZ/cbf9j3+J7+FgKKOAakMQ+7TODBWrqrKMNI9dw4SEuSkdlIB2tthzx6Vq6/2nM4qOG9RUV8veP2kwqefShYvNjwKg1y7nm3M9NXeuiK3W1HA5OfEAoBxXvBjeTCYau+6/rVlUkq0T/8IXa2oG76FUIa79M/fCfsln7jbusWL59Kn2QVVnXRVtBJ0on5Uze7oMOz9+ibOGhuhvd3wtw4K0omPn/wO2FtvtbB1a/ToG7oZZ3TbR1j4yYlafv/7d/nmN6/H1xfCwqaujAFcq9lgGOMroyzcckazwTndBkGv5nm67dXs4ZmSM3ImlWH5rMFmv7puTBfZbEZ9U0ODoLxckJuruy1JpbUVoqKmfkRyOEazqAgKkqSk6Jw4oVJSIgHBggVDG2u7C1dPsQeM60J1/oK/9Aaz/1QHuuogLNCzvOv6ezrq+56BlmrUq/8ZYbrYNr2+1MjIDoyEnk60vL8gZsw2XmPqLLe8eBbj1WyAoiIFq9VI5KmqgpMnVebMMdYRuIOGhnb8/AShoX6jbzxFjKTbUsLnPreZ3/zmET7++CRRUXPIzjY6rFPFZJRFBYzZ/mywZoNzuv2nT+oobWhH8fEsz1GvZg+P2zur4zX71TSorITAQMlLL0FQkMr69ZpTGfauQteho0OQlTV1K0knislk+JxGROg0Ngquv94zRohdOVXT/4If1he1oXzCF3yIn4VtGXH4latkZuqkpXnWQ8wFT8f2BvSTH4FiwvHi/Rf+ri79EgiB47NXoLsNzD5GHVi/2rKpstzy4jlMxKC9psboUBQWCo4fh40bYc0a91pGnTjRzNq1Y0gQ8DCEAIvFl2uvvZF33nmZ3/zmGx7R8Xb19HqfbvfYHePSbHBOt4N8LGSb48mMhHXrhvYVnyq8mj08bu2sjsfs93e7SgGY5zeTN980ERUlSU8Hm013+2hgTY0RKpCa6lmdkrEghPGkvnKlxtGjChUVgvh4zzif/lM1H59uREhBrz72qRpnFgCIoCiXXPCNjYKGBsGZM8LjOqsXa8sk5i8/Nux2yqzFQ74+VZZbXjyHiWj2+rgYtm9XMZshJUUnJsao93dn56Cjw8Fnn3WxYMHUL0yaCEJIVq+eRWtrBk899Sb33bdtqpsEDJ5el1JgH4dmw0XdHq9mg3O63dEBZ84oWK1GwtdY0isnG69mD4/bOqsFNW2DRE9qdrR9zw6Z0tBHt0Pnvz8s5dsZgSQnB5GSIgkJgbNnjUxkV1qbjEZwMCxaNH1HVcG4USxcaFhuLVumU1Eh6OnBrZ/jSKRHBfDz6zJ47yMHBV3VNDP2eLhQPwvLEkL5qHSUBQATvODb2qC+3hipttmMEpFA11pOThhX15Z5uXKYiGb/9sNSTPMDmTkziJgYSWiopLcXWloYU0zqRGltbWL9en98fKbUpXHCzJ1rWC9+7Wsb+MUvHmH//qMsWpQ1+o5uoG96/VBBL68dq0MPbB9XpGeIr4UF0aHsG8kXdRjNBud0u6cHyssVfH2NWdqmJoj2sFJmr2YPjds6q0/nVQxYiAKArg+b0iBs4Rc2s2s6+zvL+dX5VIaICJgxw72dxvZ22L1b5ZprPGPafCKYzn/rViv4+8O+fQqrVnnOdEhlpeBMsZU18xOcTgbr7TVGjA0xEqTJBPaqTfRok3fBnz6t0NVliJ7JBEePKqxY4VkPM9PRcsuLZzARze7VdD5pKudXN1xM0omIMB7u3Mmbb7Zyww3Te1QVjFADAKvVzBe/eAu//vWzJCcnEBrqGU/Hra1w8qgviwMT2LxJc8rT3OEwdFtV4fRpI2Hyquh48msmr6NWWytobQWTScdmg8JCldBQzWMGa8Cr2cPhlsfNvlSGSydJxfmUBmELRwgFJTYbzqc09EcCn55PZZgqOjsNt4HLjZgYSUyMpKFhqlti1AQXFAjq6wXnzimYzc593poGR44oHDigsmuXwnvvmVicHMA/rZ1c4+3MTJ3Fi3V6e2H+fJ158zyro9rHTZkx3Do7GauqMNrziODiZ+AJno5epgaXaHbZ1Gp2Y2MboaEK4eFTuHp0EkhOnslVVy3kmWdeRY5m0ecGSkoElZWCujoFRXFeA4uLBXl5Cnv2KLzxhgm7XbB15eQGJsTGSpYtM8ImEhN1li7VLgzeeBK3ZMfwpQyvZvfHLZ3V4VIZLmWolIY+piKVQdcNyxVdh7o6I1XlciQxUXL8uEpz89S2o7sbPvhAZe9eBZAUFKicOjX6cK+qwuzZOrW1oOuChQuNhXfb5sVcEL7JuOD371coKxM4HIYrxVTF7o5ESwts324irnsmj902j7UpYVhUMSjVxWpSsKiCtSlhPHrrvMta9LyMznTVbICGhg6klBw92syyZVPsyzdJ3Hjjas6d6+CNNw5MaTukhLw8hffeU+nokFRXq+zf71y3Ys4cSWuroKMD0tM1cnKM2b3J1O2TJwXFxYLmZoXaWkFtredpdk8PfPihgno6jke2eTW7D7c8UwyVynApl6Y0XMpUpDJ0dkJ+vorJpFNZCZmZbn17t2EyQVKSRm2tICho6vz7fHzg85938Le/mQgMNKaJnI3IPXRIwWSCiAhJZKTEZjNeH80X1cekoI/TXy8yUlJdLfD1lZw9q5CU5DkPMx0dRl13e7ugsRHmznXei9eLl+mq2boueemlY4SFaRw4oJOZmevW93cXqqryla/czEMPPcXSpcmEh4dOSTuEgOuu0/jwQ5XjxwU2m053t3M3kMJChZ4eSEw0/j8y8uLvbbL8rCMiJCdOKKiqpKNDoCigqlM/Og1GSURFhaC31yiFCw6WXs3uh1s6q5emMlzKUCkNQx7HzakMPj7g56fT1ibw9xd89plCaqp+oSN0OTFzJpSVwYkTU7eqXVGM0RiHQxAdrbF1qz5qZ7WmBlpaBPPn6wQFwfHjgpCQge0f6YLPSQxlXULwuC74WbMk5eXGqPvSpRqxsZ4hegBNTca0XHU1JCTozJ17UehH8+L14mW6araiGA/ctbXdWK3tvPzyflatSmfu3PDRd55mJCVFsnHjSh566BUeeOCrqOrULCIzmYw1HZGRsGnT6PfH1lYoLlaYPVtnzhyorxd0dg7ebjjdDg/0JTbAMq6OWlgYhIdL9u5VSUtzkJXlOZrd0WF4x9fWGkmcubn6hVplr2a7qbPaP5XhUpxPaXB/KoOqGr6qR48aC5ACAuSA9KzLjehoycGDCt3dcsrsPGw2SViYTk6OvHCh9qeyUuDnZzhCaBoUFamkpWkXUrjS0oYfGR7qgo+ICKC+vm3c7fXxEQQHg6+v54geGLVZDofGiRMmYmIkLS1iSk3EvUwvpqtmA5jNJo4e7SA7258ZM0KIj788SwEArr56GXv3nuD99/ewadOKKWmDjw+EhEgiIowZrUsHGNraoLlZEBcn0XU4dUrBZuNCpzY6emRdulS3J6rZZrPR3oCAqY+u7U9ICMyZo3PsmEpamjFrFxfn1ew+3KIk/U3aL2W4lIZLmapUhoYGgc0miYvTCZ2amRa3YbVCdrbOiRMKGRn6lBSeKwpERRmjlkNRXi4ICIBDhwTh4bB27UB3BneLT0yMTnf35Mf8jhWHAxobFb7wBQetrcLpcgovXmB6a3ZHh47d3kZa2mzWrElBHeqp9zJBURS++c0b+fnPf09KSgrJye43gxfC6Himpw89E1ZVJWhqEpw9K+juNoz4p5IZMyRhYdJj/MX7U1VlBPXYbMZ/e7mIW7oj/U3a+zNSSoOStGTgtlOUypCYqBMbKy/7jmofNpuxoKyiQrglHawva/xUfQftvQ78TCZm+vuT0Tl4iqe11Sjor6oycsUv7ai6i/5tbmp3YFVMVOz3rPqhkycVQkKMmQA/P88TZS+ezXTWbJtNsm1bBmvWzEZVL/8bfnh4KOvXb+Cpp/7KT37yd27pnF+q26pmovTYYA3s7jb+aW2FujrBtddOnfVjX5tP1HZQ1+pg/zsmUiM8R7erq6GrSxARYcwOpqR4dbs/bumsXkxlaBhghSJsYSOmNFzYjslPZbj04rNZTMQH+rMwNIrwcPOkva8nkp2tc/q0oKWFC9PrrmakrHGrSeGZIwOzxqWEAwdUDh4U5OTohIXBmTOCxET3XdAjtXlf1cj56O6krQ26uozVtl68jIfpqtkp4f6kxM9n2QLLFTWbcM01uZw+XcSrr+7i5pvXT9r7jKSBeysHa2BJieCDD1Ti4iAuTr+wcMid382wba6DncWeodsOB1RWGo5DnlSa4Em4baLXU1MZRus0PS3LWF489R0Qd6KqRk3PgQMqa9dqQ9aOToSxZo1/a3US8/xm0tkpWbJEkpWlo2nCrXWiE8lHdye6DkVFCnPm6C7/3rxcWUxXzZayjOVVV5ZmCyH4whdu4Hvf+//IyppNamqsy99jrBr4tflJRLbGkZMjSUvT8PMzyrzc2VGdLrp94oQgOvryXhMzUdQf//jHPx5pg66uXlzhOxxpsxLoY+LgmWYcuvMH7PNQW5NycTWnv7+VTheYTb90uIofvFlEyblONAmXlmdpukSTUN7YxdvH6wj0MbksHcJV5zBZGNPH0NYmho0QHc85jCVrHMChSw6caSbQx8zn1ttISpL4+hpts7hg0MaZcxhPmw+eaXbp72Uk/Pys1Nf3YrEYdlWKYrg7TCcm43oQQuDnAdN77sYTNRtc8x17NXt4fH2tzJgRxCuvvMnSpQswmQY/rY73HMajgYdrm8mao3LDShsBAcZCLFckRTl7Dp6s2/7+FzW7udlYX5CSMnW2kePB3Zrtts4qGFYUfeKnjSJ+UtfxMSn809rkQU86rhK9qfwhe7rwgdEh/OwzFR8fOaQdyVjPoaCmjR+8WTToM5ft59B2P46W9xx64fvQfg4Rk44QxiO4pksKzzWzPCmECJtrc/FGO4fh2jwafb+XpQmub/NgrHz8sYaUkqoqhYyMoZ0UPBlvZ9V1TJVmIyUWVQyp2TDx79ir2aMzc2Ykhw6dobCwktzclEF/H885jFu3pSS/yvUa6Mw5eLpu+/tb+eADB2azpLhYISVFn3ajqpd1ZxUM8VuaEEJzl52qlm5MqjJABK0mBVVAWM85xP53uO+2W/G/ZEHpRD+k4X7Ijt1PoOU9i37kdfTiTxAmMyIs4eLfXfhDng7CJwSEhUmamozR1Uunb8Z6Dr/aUUzJucGGetrux8EnANOm76CkLEc78gZIiRKRdHEbXdLcZefqOZHjPp+hGO0c+tqsFe1A3/csWt5fkG11KPHzL2wjHT3oec+jffIU+tE3kZXHUFJWTFqbhzqHiopePvtMobfXWBhnnmZl1t7OquuYKs2eF24l4PhRPrd8JaGh6qBRool8x17Ndp6MjETeeOMNZs6MIjw8ZMDfxnMOnqbbzpzDr3YUc/Lj19HGqNmT1eahzqG62s7x40YKYnq6xGLxLCut0XC3Zk9JKq4zqQzNtZLNT/+Mhx9+nbvv3kJgIC4z4386r2JAGkYfatY1sPzLCNWMbKnG8c6DiND4AeLX49B5Oq+CX27NcE1jPJyAAGOa4tAhhcWLx285MlzWOBhP6OqcdQjVDL5BKDGZ0Fw1cBvgk9NG1ri7Vm72b7PwDUZkXYusKkRqAy9Qbc+fQWqYbvh3sPhD0xm3trm7GxobBT4+RkLLsWMK8+dPjfWYl8sTZzTbpFn4171nefzxndx77yb8/V3nouLVbOcJDPTjtttu4OGHt/Nf//UP+PuP3zR7Ous2vsEoY9Rsd7XZbjccEjo6BHPn6hw5orJggXZZBg65iim9nY2UyuAXA//0T//Db397F8uWrSYoKIjc3InfgEe6+AbmWwsQINvqBwjfVFx8U83MmZLmZkFzMwQHj+8YI2WNK3M3oJftR0TNht5O9KpjqDk3DNquL2vcXUke/dusJCwAQGsoh35Pk7KlGnn2MKZbfoGw+Bov9vu9uKPNjY2Qn2+kaC1cqGM2M+3KALxMD0bSbF2HO+64hiee+D/y87MICopl/nyNgAnOwHs1e+xkZ6eSnZ3Ciy++zZ133jju40xn3R6vZrujzV1dhmbHxOhkZen4+DDtZsPcjceOveg6ZGWtZvbsjTzxxE94/vlfu+S4I118ANreZ9BLPgXNDqFxiJmZg7Zx98U31SgKpKXpHDigkJ2tDyrLcIaRssaVyNk4Tu7G8dy3QeqI5GWIuJxB27k7a9ypfPRzZeAfin74NfTSveAbhDrvepQEI5PcVW0eyqanzyOwuwVWrdLIydGnLHnMixchQEobOTmbefnl13jiibtdEgHq1ezx8eUvb+aHP3yY3buLWLUqbVzHuBx1ezTNBte0eSTNDtQgLU1j0SI54Ye5KwWP7awKAQEBOr/73U+49tol7Nv3OZYsWTL6jqMw2g9ZXfpFlMW3I+tLkLUnQR38Ebn74vMEzGaIjDQi4MZjVjxc1riUOo4PfoeSugrlmv8H9h60T/+Afuhl1Nxtg4/jxqzx0fLRAWRnkzH1Fb8A07ZfIetL0Hb8HyIoBhEcbRxnAm0eyaanzyNwYUwkd6+Iwc/Pq3pepg4hDJ340peyaGz8jA8//JQNG1ZO+LhezR4fFouF22+/kT/96UXmz4/DZhv7KMPlqNvOaDaMv81OafbMSO5cFENQkFezncVjbZN9fCA7W5KUFMJ//ucv+Id/uJeurp4JH9eZDohQFJQZqdDZhH5i19DHcePF5ykkJxtmzmVlY68CHzZrvKcDOhpR0ozaJ+FjQ0lZjl55bOjjuDFrfKR89AuoZlBUlOwtCNWEEjUHETUHvbrw4nEuaXNjIzQ1GbMHI/HS4SrueeEwu4ob6NXkoBt2j0OnV5PsOVvLN146zEuHq4Y5khcv7iE3VyeaG/HfAAAgAElEQVQoSPDNb17H3/62mzNnGid8TK9mj5958xJZujSb3//+b8hxrLq7LHXbCc2GgW1ub4faWoGUjLh40WnNPlPLt171avZY8NjOKlxcGXfzzTcSHZ3Ez3/+2wkf06kOyHmkrkNb/dDHcePF50lERkoqKgS9Y1wEmBrhj2WI6EPhEwC2cPQTu5C6huztRC/ZgwgebGrt7qzx4drcHxEysvm2RVXwt9s4eFDwzjsqJ04I8vNVOjuNrOyioqGP39+mZ7RbjJTQ7dD53a5Sr/h5mVL6NDs0NIylS1fx7LOvjauT1B+vZk+MG27YQFVVA3v2HBnzvpejbo+m2QBmRcGn258dO1Ty8wWHD6vU1wva2+HgQQW7ffA+Xs2eXDy6s9qHEIJHHvk1zz77CPn5JyZ0rOF+yLKrFf10HtLejdR19MoCZFkeInpwrY+7Lz5PwmYz4lhLS8WoI4P9uW6EjHDT2m8gqwpwvHAfjle+D4qKuujWQdu5O2u8f5ulriE1O0gdpI7U7EhdQ8xINeqfjr2F1DX0umJkzQmUmPS+PdmWG0lHh+DUKcHOnSpdXVBTA1VVgoYGQUODEbfXR0FNG7/dcYL2j57C/vK/Yn/2Xux/+3f0yqMXttGrj2Pf/gPsz3wTxzu/RrY3XBC/wpo2N31CXrwMz623LkdROti16/CEjuPV7IlhNpu4996b2b79bWpqmse073TW7fFrNgghWREdxalTgl27THR0SGprobhY0NFhjLJ2d198T69mTz5u91kdL0FBgXR0+PLQQ7/hG9/4Kl1dQzzaOEFciC/PHaoclHyC1ot+6GX0g39FL3gbee40avb1KEmD62RVAT/ZPAdf8/iXXE8Xz76h8PGB4mIFi8WC1ercOfiaVYrq2ilv7Br0N+EbhJKyHDVzM2rmZpTEhQjzQE9EAaxODmNrZvSg/SdC/++hvR16e43RoaYmQVebyon6Dmo6OtEOv472/m+RdcXQVIl+9E1AoETPRYmei17wHvqBF5C1p1CX3I4yI/VCm29bFE10tCQ2Vicw0LAt6e0VVFUZ73P4sIrDYYxam0znfQ1rW5DNlaiLb0NZcDPCPxTto9+jzFoMuob29i9QF92GuuJOaKlFL3wPJXWV27xdXY3XZ9V1eIpmCyEICZnJE09sZ82aHEJCbOP6jr2aPXGCggKor9fYuTOPJUsyEE4aenqibvf/Hrq6jH/MZqO0qrkZmupNnO1so3z3C2PW7P5tvmtdFDExkogISU+PwGKBkyeN38+hQwrNzYKICImPj1ezXYXH+ayOl/vv/zrvv/88//u/j5OVlcH27e/ygx98Z0zHCPWzsHxWKLuKGwYM1QufAEyb7h91fwGsmBV6xVigDEdurk5bG3R24nTyhqdmjfdRXi5oaFAwmyWHD6v4+0vuXBJHwduNyJytqDlbh9xPBMdguvZfR2yzxQJxcdDebqz+jI+X7N+v4OsrOX1a0toq2LdPJTSm2yjMN1sHvJ+IzUazhSMbyqGnAxEcg5K4EABl3vU4XvgXZEs1BEVfcTY9XjyX9PSZbNyYxcsvv80999zCiy++w/XXr8PHx/nfplezXcNtt63ikUf+xM6deaxf7/xiZU/W7cZGwcmTCoGBkoIChZYW2LrVwd+vjOez6hvpHqNm92+zEVttRKD29MDChTpWqzGFr+sSXRccPKhgC+/1arYbmBZlAH2YTCo//emvuP/+b7N58wYeeuhnY66HamqCO3LjsZrGd+pmRWFbevyAadsrEbPZCAzYu1d1uhwgIyqAb69JwmeMn31f1vhk5zWHh0tKSwWnTwvi43Wuukpj6WzXtnnOHElioqSjQxAbK1mwQOemm3Q2btRYvVrjYGPNkMeTXa3QWosIjkE2VyFCLlrwCLMVAiKQ5w25+2x6vHjxBK65Zj2vvfYxmzffydNP/4HKyqFrSoejvR0+nz1+zVaBLUkz6Jn4+txpjaoqfP3rt/Hccx9SVdXg9H6erNthYZLqaigoUAgNlWzYoJGQABnRrmtzTIwkK0unqwuCg43/3rJFZ/NmjfXrdY53Vw95LK9mu5Zp1VnNzy/grrtuQ9Mc2O09qKpCc3PTmI5x5IiKb2cgW+OTsY7RA9DHpHBdbDJFn4awb59CSYngxAkxZLH1lUBMDKSm6tTVOb/PtnkxF0RktIkowUXxGCpr3FXY7caoammpQkKCRny8ZOlSjehoOe42f21BMlvnDm6zonAhaSo52Zj27x+zV3xusE2P1B1oux9HSV6GCIpGOnrA7Dvwfc2+YDfuxleiTY8Xz6Sjo5tf//phWlrKqK+vxM/PSm9v65iOceaMQJ4L4qZZyVjGodk3JkSye3sFr73WRnm54NgxY6HMlUhcXAS33baGZ599BU1zfqTU03Rb16GmRpCfrxAfL0lK0klP10lPv6idY22z1aRwz5Kh2+znZ6zXmD1b4udnDNb0xY97Nds9TKvOKgiEMGM29w2Vq5SXD/1UcylSGotYursl27erWCvi+MeVY7/4/n59NGYzHD2qUFsrUNXpleframJiJEVFKufOOb/PtnkxPHrrPNamhGFRxaAbkNWkYFEFa1PCePTWeZMqeKWlcPiwgqbB4sU6q1cb0z6XBh9c2uZLR3n62pwdFs4dMfOZ5Zg5oADfWS616ZFSR/v4SVBNKEtuB0CYrGAfWEMm7V3Qr17sSrTp8eJ5CCGw200EBtowm/2oqKihutr5zqrdbsQJf/qpQufheL6+YOya/e0tacyencKBA8Xk59ehaeKKjiLesGEJPT0qL774yZj266+BZmXqdLuuzkh/OndOkJOjs3KljsUCoaGDZ1md0W2zIpjtF87XE+ezNnbmmNvj1Wz3MK0u2ZycdPLzD/P444/wH//xH9jtXZSWlpCTM3Lms8MBn31mdC4PHRJ0dwtyc3Xi9VgeujmAPx+q4JPTjQghBuRPW00KUkpWzArlzsXxF6YGVq3SKCsTlJQohIY6rmjhU1XIytJobBSEhsoLT5uj0Zc1Xtfay2Pv1dFpaadbG5g1Pln1O1JCbS2UlyvMmQOZmQOTn5YsGTrWd6R89KQQf5KVKHrbrOTnK7SY5biSvvrb9Egp0T79I3S1om74FkIx/iaCY9BL9lzczt4DbfUDoievVJseL56Fn5+Vn/zkHyksLODBB59m9+53KS097VTN5PHjgooKQWGhQnW1Qnq6TjKxPHhtAC8Vjk2zN28OZMaMDPLyiujt7SArKwFG7fJengghuOuum/jNbx5lxYpU4uKinN43PSqAX1yfwScH7OS31lDXe1EDJ1u3Gxvh7FlBRAQkJ+sEBV3824IFw0exj6TbgbqN7IAoivJ9EE2SoCBtzO3yarZ7GPXTCQuzuaMdY+JHP3qAL33pK1x77bX09goiIgI4197DSwfPUlTTSmu3g0AfE2lRgXwuN5Zom5XAQHjySWM4f9EiuO46YzrWz8+fDfNjaGjv4aVDZymqbqO1206gj5m06AC2LYglzDZwhWNvL7S2wuLFcPKkMT3g4zP2EdaIiOmfXhEREUBEBJw+DWfPQm7u6Pv0p6YGAs6G8a2vQnLy5LSxP83NUFRkfF/r1/ctDhvb9xAB3JcQNuj1qirjc9i7F44ehaVLIT4eAgOdP3Z2fCg7i8/R49DR9z0DLdWoV/8zwnTxBiDi5yMPvoRefhARm41+5HVESCwiyFhx62NSyEkMnXa/r+nWXk/FEzU7MnIZS5fm8uCDjwEWwsMDaOgYXrPDbFZCQqChwdDbzEy44w7jug0I8GfLsrFpto8PBAfDvfcuYefOE5w4UcHSpWlYxuDhCpfHb9TQ7AC+8pWbePzx1/nd7+7FbHb+c6iqguP5sDw3lE2bJrGh5+nqguPHQdNg/nwIDYWxajYMrdvNzVBWBkX5xr389GnIzobwcOePm5MYyo5T5+jVvJo9mQg5ygqlhoZ2dN0DfFD6ERERQH19G5oGHxe28frpoaPN+p6yl88K5XMZ8VQdDSYiQqe7W2HDhrE/QfWhadDRcbETUlBg+GWuXKk7PbLYdw7Tmf7n4HAY0+lpabrTI4rt7VBYqHDsmMK6dQ5mzZq8tra2QmWloKNDkJp68anc1d+DrsNzz6mUlCgsX65htQoWLdIGjNyORGGpnbte3Yu97RyOv34PFBMoF+121KVfQklagl5ViJb3HHQ0IsJnoa64E2EzFNaiCl6/e8m0Wlk6GdeDogiP7LhNNp6o2XDxO951tI2/lVSwp3xkzf5iTjznTgZhMhmrsVet0p12HhmKpiYICTFGvw4dKmffvhZuuy2VsDDnDnq5abaUkgcffI5ZsyK45Zarndq/p8eo7//kE5XMTCPbfrLo7YWKCuPempSkEx5uDAhNxvewc6fChx+q5Obq2GyQk6Od7xSPzpn6Xm79cx72tnqvZk+QkTR7Wo87v3LMSIzoGSYxom96aFdxA3vKmvjmsiQWzYuhqmrsFhz9UdWBo2Vz50rKyoxpCh8fY6T1SsNkgowMnaNHFbKy9FE7Z52dkJenouuS6GidujqF6OjR9xsrPT1QUiLo6RFER+ukpclJrTHu7oboaImq6qiqUTLS2NnLC/trOVXfQXuvA5vFRGrE4CkzKcFftZAWFEaBlJi//Niw76PEpKPc+NNBr3tterx4Mn0pP85q9j2Lk/jS0hiKi8WEtSEkxPi3EILc3ERMpjo++6yApKQUkpJCJnbwaYgQgnvu2cqPf/wIs2fPIStrZIspXTf8Rbu6jFX4DoegsVE63alzFk0zAlOqqwWRkToLF0rU8dvjjoqUoKqCxYt1Ojrguus0mrt7+aMTmg2GZs8NDuWY1L2aPYlM285q/2iz0ZAYIvjwnlLMFlxe+K0okJQkOXMG9uwxsXGjA6t19P0uN3x8wN9fUlUlSEoa+Ym7rQ3Cw3Xy88X5p2VobhZERbnmSd1uh7Iy46k8MVESGen8qPdEUBSIi5MsXqxzoLSN+18betR/Z7HCo5+WsXxWKHcuimdORADHjink5Qnm+SZyQjRil57na+jFy3j5896yMWv2o3ml+Pi6XrMB5s2LpKrKhxdeKGHDhi6ysibPccRTsdlsbN26hWeffYWf/OQbWCzDd5i6u8FkkmgalJQoJCfrVFeLIRc2jQddN0rJ6uoMG6r583XMZpccekSEgLAwnUWLJHtPtfHdv1Wwp2x0zU6PCqC8XLBzp2CunkiRV7MnlWmTYNWf4sYuvvPXo4NETyvagb7vWbS8vyDb6lDi5w/4u0OXHDzTzNKEECJsru9NBgVBfLxOTY3g3Dkx4hPndE5D6WOocwgPN4ya7XZjhLm1lWE77qWlClIK/PwEqiqIi9Mn3MnXdaiuFhQVKQQGGqPegYHD1xO7+nswmSAsDF47XsV/7Sqi5FwnmmRQ+o6mSzQJ5Y1dvFFYR3uDmaO7QmhpEVyzxkSwn5nCxma0MVx8fauf16SMoeDKQ/AmWLkOT9Tsgpo2/t+rBR6n2QEBVjIyQjl9uoJjxzpJSgpCUYYWi8tVsxMSIjhzpoojR8rIyUnl0KHjBAUFDKrnVRQoLVWR0tA5ISA21vDbnghSGrXJBQUKJhOkpEgiIxl2NHUyvofISHi1sIqf7yqitMEJzS6oo6vFzMk9wZSUqKzMNREfZeJYvVezJ8JImj0tO6s/f/8UJ2uHMMrraELMmG34l0ltkPABkx5tZjYbF/Lx4woRERKzeeiO0uUqfEIYorZ/v3r+CVwlJmbwNI7FYmxXVmb45M2aJQkbvGbJaYwV/kaaicMhyMw0apxGG02djO9hLKP+ALqUHG9qJiFK5UvX+pOeLlmSGkCQr4mDZ5rRRqk/FMI9frSTibez6jo8UbN/taOYkoYhfCQ9QLOtVhPR0REcPdpAfX0tMTEhmEyDe0qXq2YDpKYm8sQTr7Jjx4f89a9/JS0tg9jYgZ+3okBgoOTkSWPkMylJXkh4Gi9tbca6hbY2wZw5OtHRjDqa6hGajaTwXDORQSo3rPJn+XLJ4hSvZk+UyyZuFaCxs5ddJ+uHrHdSEhYAoDWUwzAfooRJjzaz2WDdOp3TpwUHDhgLr64UeyspwdfXmC46dkwhJWX4c+/uhuJiwezZckLT/+fOwdmzCj4+ktmz9Qk/6U+Egpo2frvjBB2f/BlZfRx6OiAgAnXBTSgzs5DNVWifPIVsM1J8RGg86uLP4wiOYWdzCV8IsqEoxglsmxdD+owAns4b2aZnfVokt8+LmfSELy9exkNjpxFHOVQH2lM022JRufXW2Rw/XsETTxRy000pREePw3tumlJcXExj4wn27TtFQkISXV1DJ1xpmqCsTJCUZMwijrej2tZm1KW2tQkSE/Uxrb53NePVbHufZifaMJm8mj3ZTLsu1OsuiCTrizb78qK40TeeAAkJErsdWlqMkcSp7ES5C7ud85n3RvJMeblCcrI25LlHR0tyczXmzBlfR7WjA06dUhACkpL0MVlETRZP51XQ0+tA+IWgbvoO+IciK4+h7XoMsfVH4BeMuubvwT8MpEQ/sRPHR7/HvPVH2HWdp/Mq+OXWi77BI3kE9vkazk4Im/arlL1cvkwnzZ47Nx6Hw48jRwrp7EwiOXkC0z3TBCklf/zjW3R29hIaGkNNzTlOnKhk3brB2wYHS+bO1cnNHV9HtbcXSksFnZ3GgtfZsyd3waszeDV7ejDtOqun6jsGPKmMB3dFmymKEc9WVwc7dphYv95x2XdYLRZYulRH04z60cJChaYmQUDA4A6ppsGcOXJUO5ru7otlA2D47lVUCFpaBMnJOqGhnpEi1jeChNmKmrP1wusiNhvNFo5sKEdJyAWLccJS6iAUaDPyakcaQQrxs0z6jdqLl8ngVP3gOMqx4s44yqyscGJifHjmmWKWL+9m4cKxpxpNJ4QQ/PKX9/Hxx3t48snnOHCgjH37PuOee74waFspYebM0X1IHQ5j274pfYfDGLyoqVFISNCZPds9C15Hw6vZ04dp11m9NNps3MdxY7RZZCRs2OCgvd3IM05N9bCCMhdjMhn/LFmiY7MZ7gBxccYTdGNnL68XGJYgrd0O/M0m0s4Nn3zicEBenkJurhGpV1kpqKsznspTU51PzHIHw40gya5WaK0dkFZif+7b4OgBKVH6i6SbRpC8eHEX01Gzw8JsfPWr6Rw9WsSbb3Zy1VVuSCyZQkwmlbVrV7JwYS6PPfY8H3+8B7vd6Gz21+z2HgdWxUR618hpVYWFCoGBkoQESV2doLRUEBEhWbhQc8sKf2fxavb0Ydp1Vm1jTBwZDr27i9ZWY0SuowPOnDHi/MYTkekMNpsxMlhQYFh9RERMzvt4ElYrLFggKS+Hw2faeCZ/aBunj073swRZHE9Gvzqeri6j4/vBByrh4ZKYGElurj6pvnvjZagRJKk70HY/jpK87EJaCYD59t8h7T3oJXsQtou2Ee4cQfLixR24SrMdXV20txv+nkLAyZMKCQmSyMjJefgPCLCweHEm27eX8t57hXzhC2OM55uG2Gy+/Mu/3MkXv/hVDpW18tLxoTX74/LhNdvhMGbDKisFZ88KgoMlCxZM3OllMvBq9vTBg8alnCM1wh+raehmS11DanaQOkgdqdmR+uCkKqE7eP+lP7Bs2UK+/vUfsH37p1gs9knrqPbh5wcbNujY7fDee0b9zpXA/uZK7t1+mF3FDfRqcpA49Dh0ejXJruIG7nnhMC8drgKgrk7w/vsqpaUK7e1GjWti4uQaRE+ES0eQpNTRPn4SVBPKktsHbS/MVpQ5q9E+fsp4ku87jhtHkLx4mWxSI/yxqEPX6Tir2SYhOf3ZYW6//T6+//0/8Pzz+fT09BAePrmzVCaTwrZtKcydG8zDDx/m7NkhXGguQ3bXVPKdt8au2Z2d8PbbKmVlguZmgaJIMjOlR3ZUwavZ04lpN7J6XcYMHttTPuTf9CNvoB95/cL/O0r3oWRfN6AWBcBsNvPeYw/y9qvH+fDDt3jsse/yi1+cZdGiq7nlls1s3HgVISFBk3YOUVHGKGtTkzHiOtmd5KlkrOEN3Q7d2L4LrGfiOHdOkJOjoSiGwX9srPSoaaT+9B9BklKiffpH6GpF3fAthDLMpSYlaL3Q2Qy+xgoxm3XaXZZevAzLdRkzePTTsiH/5qxmK4rCH370ZY4eaOXDDw+zb98OXnvt98yePZsNG7JZtCibyMjJWwyVlBSLj08vhw4dwW6fxaxZl+/Cq/Fqdm8vRLfHUloqSE/XCQ+XtLcL2tqkx67V8Gr29GHafcKhfhbWzI7gvcLaQfZVas7WQSJ3KX3RZtGhVu68M4err86hqOgBwsPL+eCDd3j++We5//57mTs3l2uu2czGjdeQnp7k8vPIyICTJ+H9902sXOmYkMeop1JQ0zas6Omn89COvA4djeATiLriqygzUgFD/B7ZV8ovNwWwKSYAX18AicMxugffVJIa4c+OU4JeTaLvewZaqlGv/meE6WJdl15ViLDaICQWHD3o+a8axfvBxnST1aSQEn4ZP714ueII9bOwfFYou0oaBtlXjUWzQ/0trFkTTk7OBg4e3MiMGe2Ulx/l1KnDPPPMKwQFhbFqVTaZmfPIypqFcPGqy3nzwrDZ5vKnP51i3rxOVq68/GoUJ6LZD31ays+vCuDOOwOwWAyt7umR5/XbM/Fq9vRh2nVWAb65NoWPTtY7beDbn/7RZkLAjBnQ2qqTmhpLTs5d3HffXbS0tPPBBx/y5ptv8dBD/01oaAgrV17Ltddew9q1i1BdNA8dEgLr1jno6YFTpy6/hVdP51UM6dygVxWiHfor6uq/Q4QnQlfLoG3sms6rJytYkXbREsSTO6pwcQRJtjegn/wIFBOOF++/8Hd16ZdAUXHkPWc8latmRHgipqu+jVCNk5NScn3GjKk6BS9eJoU7F8ezr7yZLvvgKf7RuDSOMjDQ8PiMiPAlI2MxsBi7XaOgoIT8/HwefPAJrNYu5s7NJjt7HitWpOPj45p56MBAf77ylQyOHj3B2293sm5dClarh9YljYOJavbfSipYlXFRs0dzeplqvJo9fRBSjpx10tDQjj5KGoO7iYgI4JH3T4wpcQLGlxih6zr79x/khRfe5pNP3qKxsZoFCzZx882b2bx5PYHjNPeMiAi44LPW2wu7dyvMni2JizM+64YGYyGWJ1gyDUf/c7iUxs5erv/9viEtaxxv/RwlZSVK6soRj29RBa/fvWTSjMBh5HMYD/e/VsCu4oYhQytGQwBrU8IGePY5g6vPYSqYjHNQFEFYmM2lx5wOeKJmA7xT0sB/vHF80jUboKamlh07DnPw4GGam08TFpbGqlXzWLkym5CQkLE2HRj4G9U0nddeK0PTOrj++tlYrVZKS+uJiAgkIMBDCzTxavZQeDV7fLhbs6dl3Kq/v5XEACuBPk5GmzF+0RNCEBs7k02b1vD1r9/Fli0309TUyRtvvMgPf/g93n57Ny0tzQQHRxAWFjymc+iLKlNVmDXLOId9+1QURXLihBFp5+Mzpua6lZHi1l7MrzK+m0u+Gqnr6HnPIsJnoX36NHrBO9BWj4iag1AGjlCYVIUAq4l5MyevftjVkXEzg3x5+3gdjnF0FnxMCj/YOGfMGeiXcwzkRPDGrXoWy+bMQNX1SddsAJvNRlZWMps2rWD9+rUIYeHkyQKefPIF3n13P+3tzSiKD+HhQU6XC/T/jSqKYO7cEPz9NV55pYzOzm7efPNTzGZfEhI8t6bLq9mD8Wr2+PDGrY4BZ6PNVpy313BFtFlSUjzf/e7dwN00NbXx7rs7ePfdt/jNb37JjBmRrF59DZs2bWbNmoVjKhcQAoKCwM9P8vHHKgkJEm2YGbMBvne9DmwWE6kRI/veTRYd5x07Ll0kNqwReHcr6Bqy4hCmTfeDoqLtfBj96Buo828asOl0tASZGxnA7XOTefZ4yZjCK/puzN74PS+XM1Oh2QEB/mzZsoQtW5Zgt2scPnyKo0fz+cUvHsVksjN/fjbp6fNYsWIuVuvY9DMhIYbsbI2HH/4rqakzOX36JMuXz8J0Sca0J2l2b69hLRUQMDBM5UrV7IyoAL4yL5mn80vo0bya7alM684qOBdtNlliEBISwG233cBtt92Aw6Gxf/8BXnjhLb773W/R3n6O3NxN3HDDZq69dj022+jTkd3dhqdofLzk4EGV2lrYuFGnb9eCmjaezhva925n8fC+d5NJW5thAD1njqS7mwuehy1dw1h5nK/zUdLWIfyMkWgl/Sq0I28OEj6YXpYgZ84ISkoE16bGEBkp+d2uUnoc+ojTSwLjBj3eESQvXqYbU6nZZrPKwoVpLFyYxp133kZVVQ0ffXSYV199m2eeeZSoqLksXjyPtWuzCQoafaasp8dBUdFJ0tKiKSnppLy8hezsaubPNxZfeaJm2+1w8KBCfLy8MEji6ytp6bzyNLuhAYqKFJaGxRC4WvK/u72a7alM+85qH1MdbWYyqSxbtoRly5YAP6a4+DQvvPAOf/rTE3znO/eQnr6MG27YzObN1zBrVuyQx2hv78Rm8yciwuj41dQonDolmT9fXrATGe5C6hud2FXcwN6yJrdcSD09UFUl6O0V7NypUFsrmDdPIylJ4mca+qclrP7gF4JxyV94ddj38HRLkO5uKCkxTMrz8lTa2yE728G2xJFHkCyKAsK1I0hevEwnplqzhRDMnBnN7bdHc/vtm2lra2fnzqMUFBzmlVdexMdnBuvXzyMnZx6pqUO3s6urh/j4BPz8LFitDRw7VsYLL+wgK+vLbC+o9jjN1nWoqTFmxI4eVSgpUUhM1MnK0rEOY9V0uWm2psHp04KuLkF5ORw7ZuK22+zcOiuGzOjhNdusKAivZk8Znv2rmsakpMzi3/7tHuAeGhpaeOutHezY8Sa/+tXPiIqKYcuWG1i5cj2rVi1AURTee+997rrrDp577lVWrFhMVJROZ6dOSYngyTnCYR8AACAASURBVI+qeSp/7L53gMvEr6XFeAqNjoZPPlEJCZGkpsK5cwJFgdhYncRESE/XCQ2F9AZ/dpeJIaeVlJTl6EU7EDEZoKjox99Hic0etN10sAQRwrjp1dVBSIgkJ0cn6Hy51rAjSBYTaruNLy6bQUqch1scePFyhRAQYGPr1mVs3boMu93BgQMnKSzM52c/exghdK6+ejGxsXNYujQNi8VMe3s7X/nK3Xz963/Htm3rsNs16upaOXiwksd2VPNc0dRqdnc3VFUZvt5Hjih0dMDGjVBRYYTqhIdLgoI0UlKMhb1ZLf58eubK0GxVNUJnVFWybJmDqCjjnEca9ffrtbExZQbz080evfD5cmXaugFM15V0druDvXvzeOutD3jrrdfo7m5m8eLNVFeXkp+/Gx8fP5588i9cddVaAAqq2/j7Fw+Pqf6xDx+TwqO3zhvwBFhbK7BaJcEjzHDV1hoxpzYb7N+vkpqq09Ul6OqC+fN1WluNqaPoaON72LfPyIGeO/fi72SklaVSd6DnPY9+Og9UM0riQpTcWy5YgfQxXVaWlpXB66+byM3VCQqSpKePfL20t8Mzz6gEBMC2bRqWCZ7edL4e+vC6AbgOT9RsmL6/UyklFRXVHD9+kr/9bQ/d3WeJi0vHbDbx+ut/wdfXwr33foubbtoCGFP/f/+C6zS7rQ3a2wXR0cN/p83NxsDBzJnGmoegIElUlM6ZMwqZmTq6Dj4+EB9vfAcnTwrOnVNYvvziwogrSbPb2uCZZ0zMnq3j6wvLlo38XUkJL75ooqEBtm1zTDgufbpeC/1xt2Z7R1bdjNlsYtWq5dx88ybq63/AqVMlPPfcW7zzzp8B6O7u5I47buE///N3fO1rX+Lp/RX0DiF6jnd+jawvhb7VmH7BmG/86YBtehw6T+dV8MutGUhpdJKOHVPIyTEESkooLweLBTo6BIWFKitWOCgrUwgIgLg4nWXLNAIDQVEuCtilAQapqfqgzu8FI/AhLEGEYkJd+kXUpV8c9nPqMwJ39+KDseJwGBfY7bc76OoS2O2j72O1QkKCpKtLUFgoiI+XhIaOvp8XL17cjxCChIQYFi6cw+bNa2ltbWXnzqP83//9N/X1lVitgfzwhz+mpKSS++67m6fzXKPZYOjL0aMKEREXVdSYxhcEB0v27FFJSTE6o52dhpYsXKgRENC3/mHoTlhUlCQhYeAK3itFs3XdKGG79lojjOf48dFT54WAWbM07HaVqiqF7u6LNpNe3IO3szrFpKYmc/31K3j4YVBVE4pixuHo5oEH/pnMhbfy6enGYYu91SW3o6SuGvbYEvjkdCO1Lb2cOupDZaVCZKTOq6+qhIcL1q51UFurEBOjk5AgmTnTgZ8fhIdfFLiRRmD7GK6jdefiePaWNU04vMFT6eyEHTtUVq82OvQgnbIMamgQBAQYZRUOB5w+rRAaOvbPyIsXL+4nMDCQLVuW8OijDmbMiEXTdNrb23jyyYeIS1nDp+UT1+zGjl5qyq0cO6YQHCwpL1c4fFiwerWDykoFX18IDpasWaP1izI13tWZmZrh7MEvd82WEnbtUkhMlBfsInNzRz/X9naw2wW+vpKmJujpEUREeLa15OWGt7PqEVhYt+4GFi7MISMjnbS0dOLjZ/LU3rMTPrKUgqd31RHfkUBHh1G/lJQkWbFCw2yGJUv6Lfpx8QNxRlQA316TNO7wBk8uYJfSKJXIzNQGCL8ztUytrUYH/+xZCA2VJCV5n9C9eJlO2O0aK1ZcTWJiDLNnxxIZGUdsbARP76uC8okeXfD4jjrSRQJNTcYIanQ05OQ4CA6GyMiLWhrgYom8nDUbjDreGTMu+pqDc5rd2Snw9wdfXyNJcfFi7+CCu/F2Vj2A+fMzeO65pwe9XtY8jO/debRDr6Ad+isiMApl/o0oUXMGbWPXdTpM7Vx/vYamQX29oKZGQXfTtda3WOBysnGSEj76SCEmRo4rIjclRaIokpkzcapswIsXL56Fr6+V73//m4Ned4Vm92o67Wo7G9ZpdHcbU9ZFRe6LdL0cNRuMErj2dli6dOw3v4gISUSEJC3NmBnz4n68nVUPpr13eL86ZcHNiOAYUFRk2X60Hf+HuP4HiIDIIY/T59UaFGTUKg3jLDUpjGYEPt0sQXp7ISICkpPHNyKqnC+R8veHDz9UWbdOu/CaFy9epi+u1GxfX2MkDyAiQnPrCvTRNNskQCiCldNEsx0OMJslOTnj0+y+z95qhbIygZ/fyIuUvbgeb2fVg7FZhv96lIikC/8tkpejn96PfvYY6tz1g4/Tz/euu9sozg8JkW4Vv+EsQfwtJlrLA1g3K5KFmRZCAjx7SrywUKG5GZYvn/jQtKqCn5/heejq6TwvXry4n8nQbIfDKB2y2VxfqjUSI9k4tZ/RiOywsCZCxdTaC1Hua9dYqamBQ4dUrrnGNR3+kBBJa6tRnuHFfXg7qx5MaoQ/O04N7Xs3NENs5+jlsx07+e2JCpYvX4kQNoQwLripoL8ReGenkfr00mcmPqsBs6axZo3nCoDDASbT+J/OhyIzU6OzUxDg4Z10L168jI5LNFuzk/fuO/xX/jEWLVrHjBnhNDaKAesL3El/ze7t1fjkk2JeO17FvrIGWuuDuf32BVPSLmfQNKPUauFC141Mp6ZKzp71lgK4G+/kowdzXcaMIV+XvZ3olQVIzY7UNfTSfci6UygzMwdtazJbSFI0/vKX/+Hmm1O4777refHF/+HQoeOMYrE76ZhMRg1tXJyOv79RxF5R4ZkiUF8Pb7+tkpIi8fNz3XGlhAMHvJehFy+XA67QbLPZwsqZoXzwwevcffdivva1DTz77H+we/de7PapjTI1mRTa2yWBgWZCQwMwmXyorfX1yNr7nh5Ds202iBxcaTFuVNWwE+vocN0xvYyOd2TVgxnW907X0PO3I1tqQCiIoCjUtf+ACBwolAJYlRzGL/7pH6mqupfy8jZ27NjNiRPvcuedjwIOFi68io0br2LLljVOZWG7EosF4uIkp08r1NYaqzRtNqMD5wkJIXV1hj1Jny/fokWury0NDISMDB1NM0TQixcv0xdXaPbKpFAe2LqKe+68g+pqBx99tJ+jRz/gRz/6NxoaysnJWc2qVeu58cb1xMbOdOfpoSiC5ctTKSvTKSoqoqoKZs60uG3B7mg0Nxt1vhaLMXOXlqYTEuLa9xACFi70kBO+gvB2Vj2coXzvhE8Api3fH3XfPt87IWDmTInJFABs4fvfvwaQFBUV88or7/P883/ie9/7BgkJWWzcuIENG65iyZIcFDes+vHxgauuciCEiYQESXy8Z0yH67qxejQ+XuPYMZVVq7RBYQiupLhYMGeOZ5y7Fy9exo8rNBsgPBx8fEw0NKzka19bhq/vA9TW1rF9+w4+/ngnDz30U2y2SNatW8eGDRtYtWopfn6Tb/xpsajccMMcNK2FM2eqmDPH4jELRP//9u49NqrzzOP49z1nPB5fBl+wPcYYgg0EbIdwCTEX04UASUkCSdpmN8kmyqJVqqRNtHTTVlptpW2rblIJqdKyW62UqGpRN9mqm6hNICQ0YAj3S4DggoGAMdhczM02+IJnxjPn3T8O2Dgx2B7PjI+Z5yNFwZ7bOfY5Pz9z5n3fp6bGwOPRnDunKCrS3HtvbDI1NVVz+LAxZEMzEpEUqw4XzXXvfD5NWtrNiVWKkpKJlJRMBL5He3sHlZU72bp1I6+++gqtrVeYO3cRc+cu4sknF5GfP8j+crfh89lh8sQTIS4dvkLKr9/BVV2Nar2G9mYQKivD/+wL6JycmLz+7RiG3Tv71CmDjg6i/u78ViNGaGpqDHodvyaEGFaimdnp6VBe3t2S2efL4+WXn+Xll58lFAqza1cV27ZtYuXKlXz/+0eZMWMW5eWLWbbsISZNKkbF4CMqrxe8XpNXXnmALe+5SPn1KtxHhz6zwZ6LcemS4swZgzlzYjdkIi3NnqhsWTimUL/bKd3HwEUn9plOxL6671edj+u6d6dP1/Pxx5X85S8bOXRoK/n5RVRULGbZssXMnv0gbndS1H4Pri/2k/Ifv8JduQFlKJTf33Wb5fGgtCa46BGur3id0PQHBv16t7rdPpw9q1i3ziQvT5OdrUlLgxkzrJgF09mzirw8HdFs30Q8H/rjTn2m72ZOzGwY/sep0zO7sbGZTZu2sm7dJg4cqCQpKZmZMxezdOkCFiz4Bl5velQzO3XVr0jauAEMheGAzG5pgY8+MgkGFZMmWYTDimnTwl3LNkbblSv2UlaRrOQy3M8FiH9mS7E6RCLZhyMXWm+77l2yy0Dr2KxVGgx2Ulm5h88+q2THjo2cOXOa2bPn8/jjS5kzp4KJE8dE/Nye1b8h/ac/Ab8fdYdDUSsFHg9tP38D//KXIn49gKbrQT6qvsiJy+0EATf2LN5lZb6uvtZVVYqdO00qKiyKiy3c7tguG7Nvn4HXqyMaCpCo50NfpFh1luF+nA6nzNZas3//ET79dDO7d1dy+PAXTJ48jaVLH2PmzAoefLA04quuTs3s8+cVa9aYTJpkUV5uoRRRnQz7VadPw7lzBhUVkTQZGN7nAkix2i+J/ovubd27CTk9T9xYOnv2IpWVlWzatJUdOz5l5MicG+/gF/PQQ3Px3NIw+fz5C6xcuYo33/zp18ZT3Qw91dHR79fWKSkRh1/1jT8cO081AfRYXubmH465Rdl8e/JYMkIZFBZaeL3xmezV0gJtbYqCAilWo0WKVWcZ7sfpcM7slpY2PvtsO9u2bWfDhvVYlp+ZMxfy0EMLWbr0b8jKyu66r9aa11//CStWvMq4cT0ncDk1s5+bOhbXtQzGjLEzOx5Nb0IhqK9XEbXLHu7nAkix2i/yi3aG3FwvFy5cZd++g/z5z5V8/vkGamqOUFY2lyVLFrF48WK2bNnIz372L0yefD9r1qzpWnHA9cV+Mp96bEChd5NOSeHqh58Qmtb/9f0G8pGc2zR4bV4xzz4Q3/aBO3eaPPBAmOTkgT3ubjmWpFiNDidmNgz/43S4bz9070NNTS0ffLCZXbs2UlW1i9GjS3j44YUsXLiQlBQXjz++iBEjMlm79mMmTrwXcHhmuwy+N7uY58vjm9mHDtkrxuQPsCnC3XQsRZMUqw50t+7DlSvNrF//GVu3bmTLlo20tTXR2RnAMFzk5RXy8cefUliYz4jlf4/7k3U9Pkaa+JUz3q8U/9Dezr+3tPT4vlaK4GNLafndu/3azpuhF8lkh3j2u963z6Cw0JLgixIpVp1luB+nw337ofd9uH7dz+bNe9i2rZLNmzfR0FBLINABaFJS0nnnnT8xb165ZHYvTp5UBAJQWjqw8+1uPZYGS4pVB0qEfejo6GD8+EJCoe4Vo12uZPas3c/0px5ABQK3fWy7Ukzz+fifpiZmB4Nfu10nJ9P4xdE+Z5xWX2jl5T/so33HO+iGoxBoB28u5oxvYYyegg6HCG/7DbqxDtobMR/5IUb+JMAOv7f+bmrc+l77/XDtmupaIaG/EuFYioQUq84y3I/T4b790L99mDdvLidOHLnRNEajlOKtX/yWl37xStwy+5X/q6IjECC8538HlNvxzmzLgnPnFIWFA2tfnijH0kDdKbNl0QURM3/96xFCoU5SUtKZMmUmzzzzMq+99q/kr/+TPfj+DtZ5PORYFrN6CT2w36l7/tj9Lr2xEZqb7XFEt1q9t55AMIRKzcL1zR/hem4V5vSnCG95G912BQCVNwFz3j9Cyogejw2ELFbvrY9gzyOTlAS7d5uEw3F7SSGE6KK1pq6uFrc7mUmT7uPJJ5fz3e/+mIX1X0Y9s1ta7Mz+6qiC1Xvr7YloljXg3I53ZhsGHD+uuHw5bi+ZsGSdVREz5eUzOHSolry8kT1mnnq/990eS5305r3UVJ7u6OB28Wj4/ZhHqrEsu1PJrl0GDQ0Gzz0XIi3NnhTVdD1oD8xPSsac9kTXY1Xh/YTTc9CNdRj35GCWLgYgrHq+d9PAjlNNNF8PxmUShGnCffeFCYWkm5UQIv6UUuzbV83IkZm4XN0hFM3M1hra2+1GKFu2mDz7bAi32868m5mtARVBbsc7s8EeAhCPCV2Jrs8fsVM/RsvNjc9l/lhKhH3Iyxvx9W8G7txU+axpstvt5ldXr97xfrqxjYMHvRw7Zr9LT0+HjRvh3nth+nT4tOrkjSK550eiuqMFWi6iMvse22Qoxea6q7z8N+P7vG+0NDTA/fcP7DGJcCyJ/nFqZsPw/x0P9+2Hvveh19ujlNlWYxt1dV727rXXKc3Phx07oKAA5s2D9V/2ntnQ/9yOd2ZnZsLu3TBp0sAelwjHUjT1Waw6cfyTjPdwhkj3wZucxp2aAr6fkkJ5MMjYPj4P7/SmEw63EwgYdHbC5cv2x0qgSU21+PxEU491DQG0ZY91MsbPQWWM6nNb/SGLg6ebuFyS1/eORUF7O1RXm4wa1f+xAIl8LN2JjFl1luF+nA737Yehz+xQejqdnW03MlvR2GgP3QoENDk5vWc2DCy3453ZAGfOmNTVhfu9rmsiH0t3cqfMlovXIu5CZWXodZ4enapu9X5qKq+13vkksDwezGllzJxpUVpqsWaNiWUpHn88RGqqvYC/dbDnAFatLcLbfwumC2PWc/3e3rZA7Nr2fVVaGkyZEiYQYMBLWAkhRCxELbOnlzFxombMmDDbtxt8+aXB88/bmZ2WBhz5etZGktvxzGyABx8Mf22+hIgumWAl4s7/zPNwm0UoPk9K4oJhsLSP8VFKa/zPPM+NJiksWmSxaFGYESO6O02lu7vfi2mtCe/8PXS0YM5/BWX0/31aenJ839M1NyuOHpVTUwjhDNHMbLAze/p0i6efDuH13ihU6ZnZEHluxzuzw2HYu1cyO5bkpyviTufmElz0cK+zS99LTeVRv5/0Ptr4BRc/0rUEimlCXp4mP19j3HJET8xNw23ar2HteReuNWAufA3l6jnwXoc70eEby2tZIfvrG6+f7DKYkJM2mN0dsLFjNWlpzvsYVwiRmKKd2QAjR4LPZxeuN92a2RBZbg9FZmdnQ36+ZHYsyTAAMSSur/gh7s2VX1u3ZOW1a30/2OPh+oof9nm3pWU+3tp5Gt3WiHV8KxguQu/9uOt2c/YLGMWzCH3wb9DeCEB44yoAXN9+E9Jz0FqzrMw3gD0bvNRUe83VlhYY0cv8NCGEiLd4ZjYQcW7rjNy4Z7ZS4PXCmTOKMWOkaI0FKVbFkAhNf4C2n78RcZ/p/rTty051M7comy01mqQX377t/ZK+88tev6+AWWOySU+KzxIot9JacfEijBghwSeEGHrxzexGSB854NxWwMyCbNJcbrRmQAv1D5bLpTl71pBiNUZkGIAYMv7lL9H28zfQKSl9LjitleoKPf/yl/r9GsvLx5Lsiuwwd5sGk/U9rFljUlurOHZMUVMTn/QrKbHweiX0hBDO4fjMdhlMdd/D2rUmBw8a1NYqjh5V3KZPQVQVFMCYMRZW/zvEigGQYlUMKf/yl7j64ScEH1uKTk7G8vRcIMXyeNDJyQQfW8rVDz8ZUOgBlOV7WTG/GM8Aw8/jMvjBgmIqJns5d06xZ49Jc7MiPT0+BWRSElRVmbS1xeXlhBCiXxyd2fOLebTcy9Wrij17DC5fVrjdxGXRfqXg7FmDM2di/1qJSIYBiCEXmjaDlt+9i7pyBc8f38U8Uo1x7SpWRibh0jL8zzzfZz/pO3l6qr2I9KottQRCVi/LTXdT2JOqVswv5umpBYRCGtMMc+mS4tAhA58vfm+bx4+3pPWqEMJxnJzZWmuWLAlRV2dw7JiipASKi+NzkWHcOItAoPemBmJwpFgVjqFzcuh4dUVMnvvpqQWU+rys3lvPjlNNKKV6LD6d7DLQWlNRlM3y8rGU5tudOVwue7aqacKSJSGamgyuXbPweGK/DmphoaamRpGRIcEnhHAeJ2a2Ut2TVBcuDHPxokFra/ckqFjKy4ODBxUFBVpaZkeZFKsiYZTme1n5RBnN14Osrb5IzZV2ghrcCibkpLGszNdrP+mCAk16OuTkwNix1o2xqwaPPhqOaSAlJcHp0waTJ4el97QQIuFEmtmZmVBWpvH57HGkly7Brl0uvvGNENnZsd3mlhZoaoLc3Ni+TqKRP4Ei4WSlunnxwTFA/1rGud2Qk9N9dXPyZLsDy7lz0NhoMHWq1WN912gxTZg1K0wwGJ8xV0II4UQDzWylwOfrzuy8PHjkkRB+P+zYYTBjhkVKSmy2dcYMi87O2Dx3IpMJVkJEIC0N8vPtziXXrtnvpmOhsxOqquQ0FUKIwUhJsa+4ZmbaVz6bmmLzOklJsHu3ebuGXyJC8ldQiAi53TBzpj2GavNmF+fPR/81cnK628cKIYSInFJQVmaRnw979pgcPhz9Eig5GXw+uboabVKsCjFIWVn2R0xer/0RUzSXm7o5BCFWVwGEECLRmCY8/HCYoiKLvXsNLlyI7vOPG6dpaIhjR4IEIMWqEFGQkmLPNM3KgosXFf3pQNhfwSCcOiWnqhBCRIvLZQ/nGj3aoqHBXjEgWgv6KwXHj0tmR5P8NIWIotJSi/HjNZ9/bnLgQHROr6IiTUGBtEURQohoGz0apk+3qKkx2LTJiMpY06ws+2+BrJMdPTLHWIgYWLAgTHs7HDpkMHKkRUFB5M/lctlXVl0uS5ZDEUKIGJg+3aK5GerqFB0dipKSwV0gaG2F1laDyZPlQkM0yJVVIWLA5YKMDMjLs6irM/D7IRSK/Pl8Pn2jM4oQQohYyMrqniPQ2gqBQOTPlZur6eyUJQGiRYpVIWLI54M5cyxqaw02bDAjLliLinTXxC2/P3rbJ4QQolt6OlRUWFy/DuvXu2hujux5Ro60ux8GAva8AxkSMDgyDECIOCgttcjLg8uXoanJoKSk/40EtLYH7G/fbnLpkoVpKsrLwyQlxXabhRAiUfl8sGBBCMuC/fsNpkyx+r2M4M1xr8ePG1RXa0aNgkmTLDIzY7e9dzspVoWIk5wc6OiAkyfh6lV7Jmpyct+Pa2hQHD+uKCy0C9zMTC2FqhBCxFhGhr1CgFJw9qxi1Cjdr85Xra1w4IBJSorG7Qa3W5OWFvvtvZvJMAAh4iglBebNs4vO9etdNDT0/Zj8fE1xsSYjA44eNUhLk3FQQggRD4Zht1AdN05TWWly5EjfZdOIEVBSYk+Ira01CIeVXGAYJClWhRgCmZn2R0ypqXDggNFjHOpXl04xDBg7VpORoWlqUjL2SQgh4swwYPHiMKNGWRw6ZPRo1NLbclc+nyY3VxMI6Kiuu52oZBiAEEMkI8P+v2HY774nTLDHRB09qhg9WnfdftOkSRrolHFPQggxBDwe+79r1yyOHTOYOdMiKQnq6xWmCYWFPavW/HzNk0+GCYVkJZfBkmJViCE2bZq9Dt+GDSZ+vz0bNSXFIiOjZ/DZYQinzneyrvYCJy630xYMkTPCwxhvMsvKfGSl9nMGgBBCiIiMGwfjxlkcOGBQX6/IzLTnEny1WAUoKID9hzvZ8XmDZPYgSLEqhENUVIT59FOD1lbFyZOKrCzd4ypq9YVWVu+tZ+cp+/OnYLg7GJNdBm/tPM3comyWl4+lLN8b780XQoiEMm2axaVL9jCuM2cgJ0f1KFgls6NHilUhHEBrOHLEICdH0dqqOXjQJDXVXqNVKXi/6jyrttQSCFn0Nr0qELKvzm6paWT36WZWzC/m6amDaJslhBDijk6eVLjdCrdbs2+fQTisycsL43ZLZkebFKtCOIBSUFZmobVduE6YoLl0SVFdbXCk8yz/ta0Wf6jvtn0a8IcsVm2pBZDwE0KIGLnnHs2oUWE8Hhg92u58tX+/wWnXWf57l2R2NEmxKoRD3Lp+38SJmokTNXtOtPKfG76kfcc76IajEGgHby7mjG9hjJ7S4/Hhqo+wqtZgLv4B/oJSVm2ppdTnpVQ+XhJCiKiz11C1/11UpCkqgn21Lfz6wy+5LpkdVbJ0lRAO9v7RegLBECo1C9c3f4TruVWY058ivOVtdNuVrvvp1ktYdfsgpXsJgUDIYvXe+qHYbCGESEh/PFxPUDI76qRYFcKhmq4H7YH5ScmY055ApeeglIFReD+k56Ab67ruG97zB8wZ3wGj+8MSDew41UTz9eAQbL0QQiQWyezYkWJVCIf6qPpir9/XHS3QchGVaY9tsk7vA8OFUTjla/dVSrH2Ns8jhBAieiSzY0eKVSEc6sTl9h5LnQBoK0R4228wxs9BZYxCd/oJf/EBZvkzvT5HIGRRc6U9HpsrhBAJTTI7dqRYFcKh2oKhHl9rbRHe/lswXRizngPAqlqLUTwblZ5z++cJhG57mxBCiOiQzI4dWQ1ACIdKd98ylklrwjt/Dx0tmIv+CXVjnJPVcBSuN2N9+Zl9x0Ar4a1vo+9bgnnfEvt5kuU0F0KIWJPMjh35iQjhUBNz09h0QhEMa6w978K1BsyH/xnl6m7P53r4ddDhrq9D697EnPm3qNH3AXaXlAk5aXHfdiGESDSS2bEjxaoQDrW0zMdbO0+j2xqxjm8Fw0XovR933W7OfgGjeFbPBykD3KmoJA9gv7tfVuaL52YLIURCksyOHSlWhXCo7FQ3c4uy2VKjSXrx7X49Juk7v+z6twIqirLJSnXf/gFCCCGiQjI7dmSClRAOtrx8LMmuyE7TZJfB8vKxUd4iIYQQtyOZHRtSrArhYGX5XlbML8YzwPDzuAxWzC+Wtn1CCBFHktmxobTWuu+7CSGG0ju7T/PGx8fwh8Lc6YxVCjwuk588NpkXZo+L2/YJIYToJpkdXX0Wq42NbViWs+rZ3Fwvly+3DvVmDIrsgzMMp304cqGV1Xvr2XGqCaUUgZDVdVuyy0BrTUVRNsvLxw67d+ex+D0YhmLkyPSoPudw4MTMhuF1rvVmuG8/yD7Em2T2wNwps2WClRDDRGm+l5VP4KzLZwAAAPhJREFUlNF8Pcja6ovUXGmnLRAiZ0QKhV43y8p8MjBfCCEcQjI7eqRYFWKYyUp18+KDY7q+Hk5XGoQQItFIZg+eTLASQgghhBCOJcWqEEIIIYRwLClWhRBCCCGEY0mxKoQQQgghHEuKVSGEEEII4VhSrAohhBBCCMeSYlUIIYQQQjhWn+usGoaKx3YMmFO3ayBkH5xB9sEZor0Pd8PPJBJO3m8nb1t/DPftB9kHp5B9GNjz9dluVQghhBBCiKEiwwCEEEIIIYRjSbEqhBBCCCEcS4pVIYQQQgjhWFKsCiGEEEIIx5JiVQghhBBCOJYUq0IIIYQQwrH+H5Q50YhkxE/fAAAAAElFTkSuQmCC\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "p = jax.nn.sigmoid(hats[-1].edges)\n",
        "fig,axs = plt.subplots(ncols=2,figsize=(12,4))\n",
        "\n",
        "spl = list(pairwise(G.graph['all_pairs'][src][dst]))\n",
        "\n",
        "def plot_route(G, pos, alpha, ax):\n",
        "    nx.draw_networkx_nodes(G, pos, nodelist=set(G.nodes).difference(set([src,dst])),ax=ax)\n",
        "    nx.draw_networkx_nodes(G, pos, nodelist=[src],node_color='green',ax=ax)\n",
        "    nx.draw_networkx_nodes(G, pos, nodelist=[dst],node_color='red',ax=ax)\n",
        "    nx.draw_networkx_edges(G,pos,edge_color='blue', alpha=0.2,ax=ax,style=':');\n",
        "    nx.draw_networkx_edges(G,pos,edge_color=[(0.,0.,0.,np.asarray(a)) for a in alpha],ax=ax);\n",
        "    nx.draw_networkx_labels(G,pos,ax=ax);\n",
        "\n",
        "spl = list(pairwise(G.graph['all_pairs'][src][dst]))\n",
        "alpha=[float(e in spl) for e in G.edges]\n",
        "\n",
        "plot_route(G,pos,alpha,axs[0])\n",
        "axs[0].set_title('Hard routing (Dijkstra)');\n",
        "plot_route(G,pos,p.flatten(),axs[1])\n",
        "axs[1].set_title('Soft routing');"
      ],
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "nbb0xhColl-G",
        "outputId": "5b3e7daa-cc33-4ff2-ad78-260bc011055d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 264
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Optimizing a real network\n",
        "\n",
        "In this section we show how to optimize a real-world network. To do this, we need to evaluate our model for all possible source-destination node pairs. For each pair, the link weights are going to be updated, optimizing the maximum link utilization. An efficient implementation is obtained by `vmap` transformation."
      ],
      "metadata": {
        "collapsed": false,
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "IuGpjojSll-H"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "outputs": [],
      "source": [
        "def apply_for_pair(w: jnp.array, src: jnp.array, dst: jnp.array, params: hk.Params, state: hk.State,\n",
        "                   graph_template: jraph.GraphsTuple) -> jnp.array:\n",
        "    nodes = jnp.zeros_like(graph_template.nodes)\n",
        "    nodes = nodes.at[src, 0].set(1)\n",
        "    nodes = nodes.at[dst, 1].set(1)\n",
        "    graph = graph_template._replace(nodes=nodes)\n",
        "    graph = graph._replace(edges=w)\n",
        "    hats, _ = network.apply(params, state, graph)\n",
        "    return jax.nn.sigmoid(hats[-1].edges.flatten())\n",
        "\n",
        "apply_for_graph = jax.vmap(apply_for_pair, in_axes=(None, 0, 0, None, None, None))\n",
        "\n",
        "temperature = 0.1\n",
        "\n",
        "@jax.jit\n",
        "def cost_fn(x:jnp.ndarray)->float:\n",
        "    '''Smooth approximation to max function'''\n",
        "    scaled_x = x/temperature\n",
        "    return temperature*jnp.dot(jax.nn.softmax(scaled_x),scaled_x)\n",
        "\n",
        "\n",
        "def cost(w: jnp.array, src: jnp.array, dst: jnp.array, params: hk.Params, state: hk.State,\n",
        "         graph_template: jraph.GraphsTuple, tm: jnp.array) -> jnp.array:\n",
        "    p = apply_for_graph(w, src, dst, params, state, graph_template)\n",
        "    flat_tm = tm[src, dst]\n",
        "    link_traffic = flat_tm @ p\n",
        "    return cost_fn(link_traffic)\n",
        "\n",
        "def true_cost(H: nx.DiGraph, tm: np.array, src: np.array, dst: np.array, x: jraph.GraphsTuple, w: np.array):\n",
        "    '''\n",
        "    Compute true cost without any soft approximation\n",
        "    :param H: topology\n",
        "    :param tm: traffic matrix\n",
        "    :param src: sender indices\n",
        "    :param dst: receiver indices\n",
        "    :param x: template graph\n",
        "    :param w: weights\n",
        "    :return: max load\n",
        "    '''\n",
        "    edge_attributes = {(int(s), int(r)): float(aw) for s, r, aw in zip(x.senders, x.receivers, w)}\n",
        "    nx.set_edge_attributes(H, edge_attributes, 'weight')\n",
        "    all_pairs = dict(nx.all_pairs_dijkstra_path(H, weight='weight'))\n",
        "\n",
        "    hard_routing = []\n",
        "    ledges = list(H.edges)\n",
        "    for sd in zip(src, dst):\n",
        "        s,d = jax.tree_map(int,sd)\n",
        "        row = np.zeros(w.shape[0])\n",
        "        path = [ledges.index(e) for e in pairwise(all_pairs[s][d])]\n",
        "        row[path] = 1\n",
        "        hard_routing.append(row)\n",
        "\n",
        "    hard_routing = np.stack(hard_routing, axis=0)\n",
        "    flat_tm = tm[src, dst]\n",
        "    link_traffic = flat_tm @ hard_routing\n",
        "    th = float(np.max(link_traffic))\n",
        "\n",
        "    return th\n",
        "\n",
        "@jax.jit\n",
        "def update(w: jnp.array, src: jnp.array, dst: jnp.array, params: hk.Params, state: hk.State,\n",
        "         graph_template: jraph.GraphsTuple, tm: jnp.array,lr: chex.Array) -> jnp.array:\n",
        "    '''Gradient descent update   constrained to positive link weights'''\n",
        "    grads = jax.grad(cost)(w, src, dst, params, state, graph_template, tm)\n",
        "    proposal = w - lr*grads\n",
        "    proposal = jnp.where(proposal < 0, 3*lr, proposal)\n",
        "    return proposal"
      ],
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "DCixZTsHll-I"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Neural network builds differentiable surrogate for discrete Dijkstra algorithm. Let's  explore the gradient of the approximation to minimize the objective TE function."
      ],
      "metadata": {
        "collapsed": false,
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "68I-B8twll-I"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'initialcost': 1.0479357359916401,\n",
              " 'finalcost_0': 0.8055977515045523,\n",
              " 'finalcost_1': 0.8055977515045523,\n",
              " 'finalcost_2': 0.8055977515045523}"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ],
      "source": [
        "n = len(G)\n",
        "\n",
        "print(\"Num nodes:\", n)\n",
        "print(\"Num edges:\", len(G.edges))\n",
        "\n",
        "srcu, dstu = np.triu_indices(n, k=1)\n",
        "srcl, dstl = np.tril_indices(n, k=-1)\n",
        "\n",
        "src = jnp.concatenate([srcu, srcl], axis=0)\n",
        "dst = jnp.concatenate([dstu, dstl], axis=0)\n",
        "\n",
        "# This controls congestion level\n",
        "tmscale = 0.6\n",
        "\n",
        "# Link weights are all initialized to 1\n",
        "w = jnp.ones_like(x.edges)\n",
        "tm = tmscale * np.random.uniform(0.0, 1.0, size=(n, n)) / (n - 1)\n",
        "\n",
        "H = G.copy()\n",
        "\n",
        "initialcost = true_cost(H, tm, src, dst, x, w)\n",
        "result = dict(\n",
        "            initialcost=initialcost,\n",
        "        )\n",
        "\n",
        "lr = 2e-2\n",
        "\n",
        "# Run 3 optimization steps\n",
        "for i in range(3):\n",
        "    w = update(w, src, dst, params, state, x, tm,lr)\n",
        "    result[f'finalcost_{i}'] = true_cost(H, tm, src, dst, x, w)\n",
        "\n",
        "w=w.block_until_ready()\n",
        "\n",
        "result"
      ],
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "Y3YFyLXnll-J",
        "outputId": "91a353d4-710b-4d0a-c526-394729a671f4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Notice how the ***true*** maximum load is reduced."
      ],
      "metadata": {
        "collapsed": false,
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "W9g7DkyAll-J"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Trainig the model\n",
        "\n",
        "Suppose you want to train the model from scratch. Below we show a brief introduction of how we trained it. Note that this is code is only for didactic purpose and it's not the most efficient implementation. For our real code check the repository [routing_by_backprop](https://github.com/krzysztofrusek/net2vec/tree/master/routing_by_backprop)."
      ],
      "metadata": {
        "id": "UxKTqAx6Ul_r"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from scipy.stats import beta\n",
        "\n",
        "def random_beta_w(G: nx.Graph) -> np.ndarray:\n",
        "    # random weights 0.5, 1.5 with mode at 1\n",
        "    w_dist = beta(a=10, b=10, scale=2)\n",
        "    w = w_dist.rvs(len(G.edges))\n",
        "    return w\n",
        "\n",
        "def _nearest_bigger_power_of_two(x: int) -> int:\n",
        "    \"\"\"Computes the nearest power of two greater than x for padding.\n",
        "    Idea taken from:\n",
        "    https://github.com/deepmind/jraph/blob/master/jraph/ogb_examples/train_flax.py\n",
        "    \"\"\"\n",
        "    y = 2\n",
        "    while y < x:\n",
        "        y *= 2\n",
        "    return y\n",
        "\n",
        "def data_fn(steps=10):\n",
        "  for _ in range(steps):\n",
        "    G = nx.barabasi_albert_graph(16,2)\n",
        "    G = nx.convert_node_labels_to_integers(G)\n",
        "    G = nx.DiGraph(G)\n",
        "    w = {k: ww for k,ww in zip(G.edges,random_beta_w(G))}\n",
        "    nx.set_edge_attributes(G, w, name='weight')\n",
        "\n",
        "    all_pairs = dict(nx.all_pairs_dijkstra_path(G, weight='weight'))\n",
        "    G.graph['all_pairs']=all_pairs\n",
        "\n",
        "    nnodes = len(G)\n",
        "    src, dst = np.random.choice(nnodes, 2, replace=False)\n",
        "\n",
        "    x,y = to_jraph(G,src,dst)\n",
        "\n",
        "    # Add 1 since we need at least one padding node for pad_with_graphs.\n",
        "    pad_nodes_to = _nearest_bigger_power_of_two(jnp.sum(x.n_node)) + 1\n",
        "    pad_edges_to = _nearest_bigger_power_of_two(jnp.sum(x.n_edge))\n",
        "    # Add 1 since we need at least one padding graph for pad_with_graphs.\n",
        "    # We do not pad to nearest power of two because the batch size is fixed.\n",
        "    pad_graphs_to = x.n_node.shape[0] + 1\n",
        "\n",
        "    pbx = jraph.pad_with_graphs(x,\n",
        "                                          n_node=pad_nodes_to,\n",
        "                                          n_edge=pad_edges_to,\n",
        "                                          n_graph=pad_graphs_to)\n",
        "    pby = jnp.pad(y,((0,pad_edges_to-y.shape[0]),(0,0)))\n",
        "\n",
        "    yield pbx,pby"
      ],
      "metadata": {
        "id": "8nhHqO6bVFdN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "for x,y in data_fn():\n",
        "  break"
      ],
      "metadata": {
        "id": "hSbOixdlYAoT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The *node* features are represented by a one-hot vector of size 2: \n",
        "\n",
        "\n",
        "\n",
        "1.   $[0,0]$ not used\n",
        "2.   $[1,0]$ source\n",
        "3.   $[0,1]$ destination"
      ],
      "metadata": {
        "id": "U96Qz03PYb9H"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(x.nodes)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DMuAcESmYW0t",
        "outputId": "648facff-337f-408d-ab09-44090a1ccacd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0. 0.]\n",
            " [0. 1.]\n",
            " [0. 0.]\n",
            " [0. 0.]\n",
            " [0. 0.]\n",
            " [0. 0.]\n",
            " [1. 0.]\n",
            " [0. 0.]\n",
            " [0. 0.]\n",
            " [0. 0.]\n",
            " [0. 0.]\n",
            " [0. 0.]\n",
            " [0. 0.]\n",
            " [0. 0.]\n",
            " [0. 0.]\n",
            " [0. 0.]\n",
            " [0. 0.]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The *edge* features indicate the weights used in the Dijkstra algorithm. Notice that some values are 0 because they are padded as XLA works with static shapes."
      ],
      "metadata": {
        "id": "G7cvcu2TYgDl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(x.edges)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fIZUYbKaYd0K",
        "outputId": "22a97e67-2926-44f3-b572-7cfca55a0799"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0.7864701 ]\n",
            " [1.1090951 ]\n",
            " [0.7248116 ]\n",
            " [0.6452629 ]\n",
            " [0.92690367]\n",
            " [1.0975343 ]\n",
            " [1.3076893 ]\n",
            " [0.7435798 ]\n",
            " [1.3075511 ]\n",
            " [1.0280837 ]\n",
            " [1.0992296 ]\n",
            " [1.1906242 ]\n",
            " [1.5735174 ]\n",
            " [1.0985241 ]\n",
            " [1.0040736 ]\n",
            " [1.291948  ]\n",
            " [0.5331162 ]\n",
            " [0.57096744]\n",
            " [1.0481824 ]\n",
            " [0.6160452 ]\n",
            " [0.8359031 ]\n",
            " [1.3763239 ]\n",
            " [1.2620989 ]\n",
            " [0.7235914 ]\n",
            " [0.5866209 ]\n",
            " [1.0458976 ]\n",
            " [0.51487595]\n",
            " [1.319676  ]\n",
            " [1.1214187 ]\n",
            " [0.97242135]\n",
            " [1.285441  ]\n",
            " [0.75857484]\n",
            " [0.93694824]\n",
            " [1.2245601 ]\n",
            " [1.1816072 ]\n",
            " [0.7320108 ]\n",
            " [1.2614944 ]\n",
            " [0.7291986 ]\n",
            " [0.7906138 ]\n",
            " [0.9247765 ]\n",
            " [1.2232394 ]\n",
            " [1.04055   ]\n",
            " [0.9684571 ]\n",
            " [0.56789637]\n",
            " [0.84254557]\n",
            " [1.0287862 ]\n",
            " [0.8344832 ]\n",
            " [0.8182591 ]\n",
            " [0.8067121 ]\n",
            " [0.8295423 ]\n",
            " [1.0590535 ]\n",
            " [0.69329035]\n",
            " [0.96840906]\n",
            " [0.6502565 ]\n",
            " [0.92289656]\n",
            " [0.93396974]\n",
            " [0.        ]\n",
            " [0.        ]\n",
            " [0.        ]\n",
            " [0.        ]\n",
            " [0.        ]\n",
            " [0.        ]\n",
            " [0.        ]\n",
            " [0.        ]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The label or *y* is a binary vector indicating the links that are part of the Dijkstra shortest path between the source and destination nodes."
      ],
      "metadata": {
        "id": "cAa_YPmpYlQV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(y)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wBuY0QbAYjnR",
        "outputId": "4e0f9c08-1f42-4a1d-fe19-6bc4c76dc49c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [1.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from typing import Tuple,Any\n",
        "\n",
        "@functools.partial(jax.jit, static_argnums=4) #4th argument is static\n",
        "def loss(params: hk.Params, state: hk.State, x:jraph.GraphsTuple, y:jnp.ndarray, is_training=True) -> Tuple[Any, Any]:\n",
        "    hats, state = network.apply(params, state, x)\n",
        "    mask = jraph.get_edge_padding_mask(x)[..., jnp.newaxis]\n",
        "\n",
        "    losses = [jnp.mean(optax.sigmoid_binary_cross_entropy(hat.edges, y), where=mask) for hat in hats]\n",
        "    final_loss = sum(losses)/len(losses) if is_training else losses[-1]\n",
        "    return final_loss, state\n",
        "\n",
        "@jax.jit\n",
        "def update(params, state, opt_state, x,y):\n",
        "    (l, s), grads = jax.value_and_grad(loss, has_aux=True)(params, state, x,y, True)\n",
        "    updates, new_opt_state = opt.update(grads, opt_state)\n",
        "    new_params = optax.apply_updates(params, updates)\n",
        "    return l, s, new_params, new_opt_state"
      ],
      "metadata": {
        "id": "d853ye9hYnMR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "losses=[]\n",
        "\n",
        "params, state = network.init(jax.random.PRNGKey(42), x)\n",
        "opt = optax.adam(learning_rate=0.001)\n",
        "opt_state = opt.init(params)\n",
        "\n",
        "for x,y in data_fn(256):\n",
        "  l, state, params, opt_state = update(params, state, opt_state, x,y)\n",
        "  losses.append(l)"
      ],
      "metadata": {
        "id": "VZQbvmdgbX6n"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "pd.DataFrame(dict(loss=np.concatenate([losses]))).ewm(span = 32).mean().plot()\n",
        "plt.xlabel('step');"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 285
        },
        "id": "8MwKfjEHcXc8",
        "outputId": "ba3e9495-4ffe-441d-d85d-4418c9c06d67"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 2
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython2",
      "version": "2.7.6"
    },
    "colab": {
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}