C3W3_24HUFFMAN_CODES_25_DYNAMIC_PROGRAMMING.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# XXIV. HUFFMAN CODES \n",
    "\n",
    "A greedy algorithm used for constructing a certain kind of prefix-free binary codes know as Huffman codes.\n",
    "\n",
    "### Binary Codes\n",
    "So a binary code is just a way to write down symbols from some general alphabet in a manner that computers can understand. That is, it's just a function mapping each symbol from an alphabet, capital sigma, to a binary string, a sequence of zeroes and ones.\n",
    "\n",
    "    Let   A, B, C, D   ∈  Σ\n",
    "\n",
    "So this alphabet capital sigma could be any number of things but, you know, as a simple example, you could imagine it's the letters a through z, say in lowercase, plus maybe the space character and some punctuation. So maybe, for a set of size 32 overall. And if you have 32 symbols you need to encode in binary, well, an obvious way to do it is, there happens to be 32 different binary strings of length five, so why not just use one of each of those for your symbols.\n",
    "\n",
    "So this would be a fixed length code, in the sense we're using the exactly the same number of bits, namely five, to encode each of the symbols of our alphabet. This is pretty similar to what's going on with ASCII codes.\n",
    "\n",
    "### Ambiguity\n",
    "So a new issue arises when you pass from fixed-length codes to variable length codes. So let me illustrate that with a simple example. Suppose our alphabet sigma is just four characters, A, B, C, D. So the obvious fixed length encoding of these characters would just be 00, 01, 10, and 11. \n",
    "\n",
    "    A, B, C, D = {00, 01, 10, 11}\n",
    " \n",
    "Well, suppose you wanted to use fewer bits, and wanted to use a variable length encoding, an obvious idea would be to try to get away with only one bit for a couple of these characters. So, suppose instead of using a double 0 for A, we just use a single 0. And instead of using a double one for D we just use a single one.\n",
    "\n",
    "    A, B, C, D = {0, 01, 10, 1}\n",
    "\n",
    "So that's only fewer bits. So that seems like that can only be better. But now, here's the question. Suppose, someone handed you an encoded transmission consisting of the digits 001. What would have been the original sequence of symbols that led to that encoded version? \n",
    "\n",
    "There is not enough information to know what 001 was supposed to be an encoding of. AB and AAD both would give you 001.\n",
    "\n",
    "\n",
    "### Prefix-Free Codes\n",
    "\n",
    "So lest you think this is too strong a property, certainly interesting and useful variable length codes exist that satisfy the prefix-free property. So one simple example, again just to encode the letters A, B, C, D. We can get away with encoding the symbol A just using a single bit, just using a zero. Now, of course, to be prefix free, it better be the case that our encodings of B and C and D all start with the bit 1. Otherwise we're not prefix free. But we can get away with that, so let's encode a B with a one and then a zero, and now both C and D better have the property that they start neither with 0 nor with 10. That is, they better start with 11, but let's just encode c using 110 and D using 111. So that would be a variable length code. The number of bits varies between one and three, but it is prefix free. And again, the reason we might want to do this, the reason we might want to use a variable-length encoding, is to take advantage of non-uniform frequencies of symbols from a given alphabet. \n",
    "\n",
    "    A, B, C, D = {0, 10, 110, 111}\n",
    "\n",
    "So let's continue with just our four-symbol alphabet, A, B, C, and D.<br>\n",
    "And let's suppose we have good statistics in our application domain about exactly how frequent each of these symbols are. So, in particular, let's assume we know that A is by far the most likely symbol. Let's say 60% of the symbols are going to be As, whereas 25% are Bs, 10% are Cs, and 5% are Ds. \n",
    "\n",
    "    frequent(A, B, C, D) = {60%, 25%, 10%, 5%}\n",
    "\n",
    "So why would you know the statistics? Well, in some domains you're just going to have a lot of expertise. In genomics you're going to know the usual frequencies of As, Cs, Gs and Ts. For something like an mp3 file, well, you can literally just take an intermediate version of the file after you've done the analog to digital transformation, and just count the number of occurrences of each of the symbols. And then you know exact frequencies, and then you're good to go. So let's compare the performance of the obvious fixed length code, where we used 2 bits for each of the 4 characters, with that of the variable length code that's also prefix-free that we mentioned on the previous slide. And we're going to measure the performance of these codes by looking, on average, how many bits do you need to encode a character. Where the average is over the frequencies of the four different symbols?\n",
    "\n",
    "    Fixed-length encoding = 2 bits / character\n",
    "    Variable-length encoding = 1.55 bits / character\n",
    "    \n",
    "So for the fixed-length encoding, of course, it's two bits per symbol. We don't even need the average. Just whatever the symbol is, it uses exactly two bits.<br>\n",
    "On average, for an average character, given these frequencies of the different symbols, variable length encoding  requires 1.55 bits per character. Well, 60% of the time, it's going to use only 1 bit, and that's where the big savings comes from. 1 bit is all that's needed whenever we see an A, and most of the characters are As. We don't do too bad when we see a B either, which is 25% of the time. We're only using 2 bits for each B.\n",
    "Now it is true that Cs and Ds, we're paying a price. We've having to use 3 bits for each of those, but there aren't very many. Only 10% of the time is it a C and 5% of the time is it a D. And if you add up the result, that's taking the average over the simple frequencies, we get the result of 1.55.\n",
    "\n",
    "\n",
    "\n",
    "###  Prefix-Free Codes:   Problem Definition \n",
    "There's clearly this opportunity to design binary prefix-free codes which improve over the obvious fixed link solution. So, we'd like to have in some sense, optimal algorithm for this problem and for that, we of course need a crisp problem definition. So, to do that it turns out to be useful to think of codes as binary trees. \n",
    "\n",
    "                                      binary codes   <--->   binary trees\n",
    "![binary codes   <--->   binary trees](images/6_binarycodes_binarytree.png)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "So in general, any binary code can be expressed as a tree in this way, with the left-child pointers being labeled with 0's, the right child pointers being labeled with 1's, and the various nodes being labeled the symbols of the given alphabets, and the bits from the root down to the node labeled with the given symbol corresponding to the proposed encoding for that symbol.\n",
    "\n",
    "And what's cool about thinking about codes as trees is that the really important prefix-free condition, which seems like a nuisance to check in the abstract, shows up in a really clean way in these trees, namely the prefix-free condition is the same as leaves being the only nodes that have labels. No internal nodes are allowed to have a label in a prefix-free code. The reason for this is that we've set it up so that the encodings correspond to the bits along paths from the root to thelabeled node. So being a prefix of another corresponds to one node being an ancestor of the other, and so, if all the labels are at the leaves, then of course nobody is an ancestor of the other and we have no prefixes. \n",
    "\n",
    "A final important point about this correspondence is that the encoding lengths of the symbols, the number of bits needed to encode the various symbols, are just the depths of the corresponding leaves in the tree that corresponds to the code. \n",
    "\n",
    "    If  T = tree with leaves <--> symbols of Σ\n",
    "    Then summation over Σ to take the average\n",
    "    \n",
    "        L(T) = Σ p_i * (depth of i in T)\n",
    "\n",
    "\n",
    " Huffman used bottom up approach. Not only are we going to get optimal codes, but we're going to get the blazingly fast greedy algorithm that constructs them. So what do I mean by bottom up? I mean we're going to start with just a bunch of nodes, each one labelled with one symbol of the alphabet. So, in effect, we're starting with the leaves of our tree. And then we're going to do successive mergers. We're going to take at each step two sub-trees thus far and link them together as sub-trees under a common internal node.\n",
    " \n",
    "Which pairs of symbols are \"safe\" to merge?<br>\n",
    "If we just wanted to make a myopic decision, that looks good right now, how would we even do that? What's our greedy criteria that's going to guide us to merge a particular pair of trees together? So what are the ramifications when we merge two subtrees, each containing a collection of symbols? Well, when we merge two subtrees, we introduce a new internal node which unites these two subtrees under them, and if you think about it, at the end of the day on the final tree, this is yet another internal node that's going to be on the root to leaf path, for all of the leaves in these two sub trees. That is, if you're a symbol and you're watching your subtree get merged with somebody else then that's another bit in my encoding. That's yet one more node I have to pass through to get back to the root.  And remember the consequences of a merge is going to be an increase in the encoding length by one bit, whichever two symbols we're going to pick. Now we want to do is minimize the average encoding length with respect to the frequencies that were given. So which pair of symbols are we the least unhappy to suffer an increment to their encoding length, was going to be the symbols that are the least frequent. \n",
    "\n",
    "![binary codes   <--->   binary trees](images/7_HuffmansGreedyAlgorithm.png)\n",
    "\n",
    "\n",
    "### Huffman's Algorithm\n",
    "So how does the algorithm work in general? Well just as you'd expect given the discussion on this concrete example. I'm going to take as the base case when the alphabet has just two symbols, in that case the only thing to do is encode one with a zero, the other with a one.\n",
    "\n",
    "Otherwise, we take the two symbols of the alphabet that have the smallest frequencies. You can break ties arbitrarily, it's not going to matter, it's going to be optimal either way.\n",
    "\n",
    "We then replace these two low frequency symbols A and B with meta symbol AB, intended to represent both of them in some sense. As we just discussed with those semantics, we should be defining the frequency of the meta symbol AB as the sum of the frequencies of the symbols that it comprises. We now have a well defined, smaller sub problem. It has one fewer symbol than the one we were given. So, we can recursively compute a solution for it. So, what the recursive call returns is a tree who's leaves are in one to one correspondence with sigma prime. That is, it does not have a leaf labeled A, it does not have a leaf labeled B. It does have a leaf labeled AB, so we want to extend to this tree T prime to be one who's leaves correspond to all of sigma. And the obvious way to do that is to split the leaf labeled AB, replace that with a new internal unlabeled node with two children which are labeled A and B. The resulting tree capital T with leaves and correspondents to the original alphabet sigma is then the final output of Huffman's Algorithm.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sigma ['A', 'B', 'C', 'D', 'E'], heap [[0.1, 'E'], [0.15, 'D'], [0.2, 'C'], [0.28, 'A'], [0.27, 'B']]\n",
      "\n",
      "sigma ['A', 'B', 'C', 'ED'], heap [[0.2, 'C'], [0.25, 'ED'], [0.28, 'A'], [0.27, 'B']]\n",
      "\n",
      "sigma ['A', 'B', 'CED'], heap [[0.27, 'B'], [0.28, 'A'], [0.45, 'CED']]\n",
      "\n",
      "sigma ['CED', 'BA'], heap [[0.45, 'CED'], [0.55, 'BA']]\n",
      "\n",
      "[[['CEDBA', 'CED', 'C'], {'weight': '00'}], [['CEDBA', 'CED', 'ED', 'E'], {'weight': '010'}], [['CEDBA', 'CED', 'ED', 'D'], {'weight': '011'}], [['CEDBA', 'BA', 'B'], {'weight': '10'}], [['CEDBA', 'BA', 'A'], {'weight': '11'}]]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAb4AAAEuCAYAAADx63eqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3XdUVGf+BvBnGgzVBooKgoiCihUVxQaxoBCNClhJLHE1QcSYqjHrzxizSYjRtWBLLFGxwGAsiV2KFWkRFaVJQFBRQBEpA0z5/WGY1QAKODPvlO/nnD1nl5m581z33nnmvfPeezlyuVwOQgghRE9wWQcghBBC1ImKjxBCiF6h4iOEEKJXqPgIIYToFSo+QggheoWKjxBCiF6h4iOEEKJXqPgIIYToFSo+QggheoWKjxBCiF6h4iOEEKJXqPgIIYToFSo+QggheoWKjxBCiF6h4iOEEKJXqPgIIYToFSo+QggheoWKjxBCiF6h4iOEEKJXqPgIIYToFSo+QggheoWKjxBCiF7hsw5AtFthaSVEiXlIzS9BiVgCcyEfTlbm8HOxRitTQ9bxiA6gbYwoG0cul8tZhyDaJzm3GCHRmYhJLwAAVEpkiseEfC7kANwdLREw3AG9bJozSkm0GW1jRFWo+Eij7Y3NxrfHUyGWSPGqrYfDAYR8HpZ5OcF/oJ3a8hHtR9sYUSUqPtIozz+QbqOiWvb6J//NSMDFMq+u9MFEGoS2MaJqVHykwZJzizH151hUVEtrPZYfugTVj/6C9cK94PAFtR43EvBwcN5A9LSmQ1Kkfv/cxvI2zYGsvBjg8gAOFwYWNjBxfgumvceAw3l5bh5tY6ShaFYnabCQ6EyIJbVLT1L8EJV5twAOB+WZV+t8rVgixaboTFVHJFqurm3M0nc5OnwcDusPd8B8oB+exkag6Pj6Wq+lbYw0FBUfaZDC0krEpBfU+XtL6c1IGLZzhEmPESi7ca7O18vlQFRaAYpKK1WclGirV21jAMAVmsC4syss3/kcZTfOoaog+6XHaRsjDUXFRxpElJhX72NlNyNh0t0dJt09UPFXEqRlT+p8HgeAKKn+5RD99qpt7EWG7RzBM7dAZe6tWo/RNkYagoqPNEhqfslL08lriHNTICl5BGOnITC0cgC/eVuUpcTUuQyxRIbUB89UHZVoqfq2sbrwTFtCJq69LdE2RhqCio80SIlYUuffy26eg1HHPuAZNwMAmHQbjtKbdR/ufL6capXkI9qvvm2sLtJnReAKzepZDm1j5NXoyi2kQcyFtTcVWXUlylIvAjIZcjf4P/+jpBqyyjJUPcyCQRv7OpZTe8YnIUDd21hdKh+kQ/qsCIbW3epZDm1j5NWo+EiDOFmZw5Cf/9KhqIqMWHA4XLSduxEc3v8+bAoOf4/Sm5Fo+Y/iE/K5cGpb97d0Quraxl4kqyyHOPcmnpzdBpPu7jBobVfrObSNkYag4iMN4utijbVn01/6W+mNczDpMRL8Zq1f+ruZy9t4fHYrWnjMBofLU/xdDsC3r7U64hItVNc2BgAFopV/n8fHgaCVDcz7T4Bpn7F1LoO2MdIQdAI7abB5exJw5vbDV15Cqj4cDuDZrQ22+PdTfjCiM2gbI+pAk1tIgy1wd4CQz3v9E+sg5PMQ4O6g5ERE19A2RtSBio80WC+b5ljm5QQjQeM2m+fXUXSiS0mR16JtjKgD/cZHGqXmIsB05XyiKrSNEVWj3/hIk1zPK8am6ExEpRWAg+cnDtcQ8rmQyeV4y6k1Atwd6Fs4aRLaxoiqUPGRN1JUWglRUh5SHzxDibga5kIBnNqaIdCrH6ZNGoddu3aBy6Uj6qTp6tvGFnr3h9/4sdizZw9tY6RRqPiI0kmlUvD5fPD5fIwcORIikQgmJiasYxEdIpPJwOPxwOPxMGLECBw6dIi2MdJg9DWJKF1JSQkMDAwgkUgQFRUFFxcX5Ofns45FdEhpaSkEAgGkUiliYmLQp08f3L9/n3UsoiWo+IjSlZSUgM9/Pm9KJpMhNzcXt27VvpI+IU1VUlICgeD51YJkMhny8vKQkpLCOBXRFjSrkyhdWVkZysvLYWVlBbFYjOzsbDRr1ox1LKJDaraxNm3aKLax5s1pggtpGBrxEaVzcnJCQkIC7t+/D2dnZ5w5c4Z1JKJjOnfujISEBDx48AC9e/fG6dOnWUciWoQmtxCVCg8Px/r163HhwgXWUYiOOnToEH766SdcunSJdRSiJWjER1RqwoQJyM7ORlJSEusoREeNHz8eeXl5SEhIYB2FaAkqPqJSAoEAAQEB2LBhA+soREfx+XwsWLCAtjHSYHSok6hcYWEhOnfujLS0NLRu3fr1LyCkkR4/foxOnTohNTUVbdq0YR2HaDga8RGVs7CwgI+PD7Zt28Y6CtFRLVu2xOTJk7F161bWUYgWoBEfUYvk5GR4eXkhOztbcf4VIcp08+ZNjB49GtnZ2TAwMGAdh2gwGvERtejVqxc6d+6MiIgI1lGIjnJ2dkbXrl0hEolYRyEajoqPqM2iRYuwfv161jGIDqNtjDQEFR9Rm3HjxuH+/fuIj49nHYXoKG9vbzx69AhXr15lHYVoMCo+ojY1087pGzlRFR6Ph8DAQNrGyCvR5BaiVjXTzm/fvg0rKyvWcYgOKi4uhr29PW7evIl27dqxjkM0EI34iFq1bNkSU6ZMoWnnRGWaN2+OadOm0TZG6kUjPqJ2KSkpGDlyJLKzs2FoaMg6DtFBt2/fhoeHB3JycmgbI7XQiI+oXffu3dG9e3eEh4ezjkJ0VNeuXdGrVy8cPHiQdRSigaj4CBNBQUFYt24d6IADUZWgoCCsX7+etjFSCxUfYcLb2xuPHz+maedEZcaOHYunT5/iypUrrKMQDUPFR5igaedE1bhcLhYuXIh169axjkI0DE1uIcwUFxejY8eOuHnzJtq3b886DtFBJSUlsLOzw/Xr12Ftbc06DtEQNOIjzDRv3hzTp0/Hli1bWEchOsrc3Bz+/v7YvHkz6yhEg9CIjzCVmpqK4cOHIycnB0KhkHUcooMyMjIwePBg5OTkwMjIiHUcogFoxEeYcnJyQp8+fWjaOVGZzp07o3///ti/fz/rKERDUPER5ujUBqJqdGoDeREVH2FuzJgxKC0txaVLl1hHITpq1KhREIvFuHDhAusoRANQ8RHmaqad06kNRFVoGyMvosktRCPUTDtPTk6GjY0N6zhEB5WWlsLW1hZJSUmwtbVlHYcwRCM+ohHMzc3x7rvvYtOmTayjEB1lamqKmTNn0jZGaMRHNEdGRgbc3Nxw9+5dmnZOVOLOnTtwdXXF3bt3YWxszDoOYYRGfERjdO7cGa6urti3bx/rKERHderUCW5ubggNDWUdhTBExUc0Ck07J6pGp88QKj6iUUaNGoWqqirExMSwjkJ01IgRIyCXyxEVFcU6CmGEio9oFA6HQ9POiUpxOBzFkQWin2hyC9E4NdPOExMTYWdnxzoO0UFlZWWwtbVFXFwc7O3tWcchakYjPqJxTE1NMWvWLJp2TlTGxMQEs2fPRkhICOsohAEa8RGNlJWVhQEDBiAnJwcmJias4xAdlJ2dDRcXF+Tk5MDU1JR1HKJGNOIjGsne3h6DBw/G3r17WUchOsrOzg7Dhw/Hnj17WEchakYjPqKxIiMjsXDhQty8eRMcDod1HKKDoqOj8eGHHyIlJQVcLo0D9AWfdQCiGoWllRAl5iE1vwQlYgnMhXw4WZnDz8UarUwNWcdrEA8PD3A4HERGRmLEiBGs4xAdNHz4cAgEAhw6fgaFZg5avb+QhqMRn45Jzi1GSHQmYtILAACVEpniMSGfCzkAd0dLBAx3QC+b5oxSNty2bdvw+++/4+jRo6yjEB2UnFuMz389i/RnAhgYGGj9/kIahopPh+yNzca3x1Mhlkjxqv9XORxAyOdhmZcT/AfaqS1fU5SXl6NDhw64evUqOnXqxDoO0SGK/aVaild9CGrT/kIahopPRzzfiW+jovr5N9a8TXMgKy8GOFxwuDwYWndFS88F4JtbKl5jJOBimVdXjd+Zv/jiC1RXV2PNmjWsoxAdYdnWGkWFBQDnf7/rmfYYAQOrzig6sR4cvgEAgGvcDMIOPdBskB/M29hoxf5CXo+KTwck5xZj6s+xqKiWKv6Wt2kOWnkFwciuN+SSKhSd2gSZuBStfb566bVGAh4OzhuIntaaexgnJycHffv2pWnnRCmSc4vRr4cjWo59vn+8qPT6WZRePw0r/2DIZVJInj5CSdxvKEuJgtW7P6JZu04av7+Q16NpTDogJDoTYom03sc5fAOYOA1GdeHdWo+JJVJsis5UZbw3ZmtrC3d3d+zevZt1FKIDQqIzX3loswaHy4OgRVu08gyA0MYZTy/u04r9hbweFZ+WKyytREx6wSt/05NVi1F2+wIM2znWekwuB6LSClBUWqnClG+u5tqKMpns9U8mpB41+0uDmu8Fxl0GQZx7S2v2F/JqdDqDlhMl5tX7WEHEKoDLg7yqAjyT5mg9eWWdz+MAECXlYf4wzZ08MmzYMAiFQpw5cwaenp6s4xAt9eL+UrN/1GjhMRscbt0fiTyzVpCJnwHQjv2FvBoVn5ZLzS95aQr2iyx9vnr+G59MioqMq3i4bwnazd0MnmmLl54nlsiQ+uCZOuI22YtX1KfiI0314v5Ss3+8qPT62TpfJ3lWBK7QDIB27C/k1ehQp5YrEUte+xwOlwdjRzeAw4U4L6We5VQrO5rSTZs2DfHx8cjIyGAdhWiphuwvdalIvwKhTbcXlqP5+wupHxWfljMXvn7QLpfLUZ4eC5m4FIJWNvUsR6DsaEpnZGSEuXPnYsOGDayjEC3VkP2lhlwmRXVxPh6f3gLx3RtoNnj6C8vR/P2F1I8OdWo5JytzGPLz6zzcWSBa+fw8JQ4HfHNLtHp7MQwsbWs9T8jnwqmtmTrivrGAgAD07NkTq1atgrm5Oes4RMvU7C/AC/vH34R2vWHceSAq76Xi7k++AOTgGplD2KEH2s5cC4HF8y+N2rS/kLrReXxarrC0EoN/iKz3d76GMORzcfmLt7TmmoRTpkyBm5sbFi1axDoK0TL6uL+Q2uhQp5azMDXE8C6WaOrNCzgcwMPRUqt24qCgIGzcuJFObSCNZmFqCJd2RkATtx1t3F9IbVR8OmCBuwOEfN7rn1gHjlSCA8vnYPz48Vi7di3Onz+PsrIyJSdULjc3N5ibm+PEiROsoxAtc+jQIURu+AJN3F0g5PMQ4O6g3FBE7ehQp47457U6G8JIwMU0JyFW+I+AXC6HgcHz6xOOGjUKv//+u6qiKsXu3bsRGhqKU6dOsY5CtIBEIsHSpUsRHh4OkUiEVIlFk/YXulanbqDi0yFNvTuDu7s7YmJiAACGhoZISkpCt27d6l+ABqisrIStrS2ioqLQtWtX1nGIBsvPz8eUKVNgbGyMvXv3olWrVgB0824mpGF4K1asWME6BFGOntbNMayzBZ6UVSH3SQUEXA4ksv/t0UI+FzwuByO7tkawT0+M6mYFAHB0dMT+/fvB4/FgamoKPp8Pd3d3jb4jNZ/PR0lJCWJiYuDt7c06DtFQFy5cgKenJ/z8/LB161aYmJgoHmvI/iKTSSHPTcbuBaPh3bsDi1UgKkAjPh1VVFoJUVIeUh88Q4m4GuZCAZzamsG3b913lB46dCicnZ2xcuVKzJgxAxKJBPv370ebNm0YpG+Y+/fvw9nZGVlZWWjenK6WT/5HLpdj7dq1CA4Oxq5duzBmzJhXPr++/eX28V1Y98Mq2NjYIDo6Gvb29mpaA6JKVHwEwPPfQHg8HjgcDqRSKVasWIFdu3bh4MGDcHNzYx2vXjNmzICLiws+/vhj1lGIhigpKcGcOXOQk5MDkUgEW9va56421OLFi/Hf//4XHA4HZmZm+OOPPzBkyBAlpiUsaO6xLKJWfD4fnL/PieDxePjmm2+wZcsWTJw4EevXr4emfj+qObVBKq3/tkxEf6SkpKB///6wtLTExYsX36j0AKCwsBDA8xGkWCzGzJkzlRGTMEbFR+rl7e2N2NhY7Nq1C9OmTUNpaSnrSLW4urrC0tISf/zxB+sohLF9+/bB3d0dy5Ytw+bNm2Fo+Obn2j1+/Bh8Ph8GBgZ47733kJycrISkhDU61EleSywWIzAwEJcvX0ZERITGzaIMDQ3Fzp07cfZs3VfWJ7qtqqoKn3zyCU6ePImIiAj07NlTacs+e/YspFIpioqK8PPPPyMqKkppyybsUPGRBtu+fTuWLFmCkJAQTJ48mXUchaqqKtjZ2eH06dNwdnZmHYeoUW5uLvz8/GBlZYVdu3apbJJTdXU17OzscOLECaUWK2GDDnWSBnv//fdx+vRpLFmyBB999BGqqqpYRwIAGBgY4IMPPqC7NuiZs2fPYsCAAZg0aRJ+++03lc7sFQgECAgIoG1MR9CIjzTakydP8N577+Hx48cICwtD+/btWUfCw4cP4eTkhDt37qBly5as4xAVkslk+O677xASEqL4XU8dCgoK0KVLF2RkZMDCwkIt70lUg0Z8pNFatGiBI0eOwNvbG/3799eI3z3atGmDcePGYfv27ayjEBV68uQJxo8fj+PHjyM+Pl5tpQcAlpaWmDBhAn755Re1vSdRDRrxkTdy9uxZvPvuu/joo4/w+eefK06JYCEhIQG+vr7IzMwEn0+3mtQ1f/75J3x8fPDOO+8gODgYAoH6bwb7559/Yvz48fjrr79oG9NiNOIjb2TkyJGIi4vD4cOHMXHiRBQXFzPL0q9fP7Rv3x5Hjx5lloGoxo4dOzB69Gh8//33WLt2LZPSA4A+ffqgY8eOOHz4MJP3J8pBxUfemI2NDWJiYmBjY4P+/fvj+vXrzLIEBQVh/fr1zN6fKFdFRQXmzp2L1atX4/z58xoxm5i2Me1HxUeUwsDAABs2bMDXX3+NESNGYPfu3UxyTJo0CZmZmXSisQ7IysrC4MGDUVpairi4OI05f3TChAnIzs7Gn3/+yToKaSIqPqJU06dPR3R0NL799lt88MEHEIvFan1/gUCADz/8kKada7nff/8dgwYNwuzZs7F//36YmpqyjqTA5/MREBBAoz4tRpNbiEoo80LBjUXTzrWXtlwgvaioCA4ODkhLS0Pr1q1ZxyGNRPfjIyphaGgIPz8/lJaWYvbs2XB2doaDg4Na3tvExATp6enIzs7G0KFD1fKe5M0VFBRg4sSJyMnJwZkzZ+Dk5MQ6Ur2MjY1x584dZGVlYdiwYazjkEaiER9RuQsXLmDq1KmYN28e/v3vf6vlBrc1086zsrKYzQAkDXf16lX4+fnB398fK1eu1IpTBa5fv46xY8ciOzubtjEtQ7/xEZUbOnQoEhMTERkZCW9vbxQVFan8PWnauXaQy+UICQnBuHHjsGHDBvznP//RitIDgJ49e6JLly6IiIhgHYU0EhUfUQsrKyucO3cOzs7OcHFxQXx8vMrfc9GiRTQBQYOVlZXh3XffxbZt23D58mW88847rCM1Gp3aoJ2o+Ija8Pl8/Pjjj1izZg28vb2xdetWld7g9p133kFOTg6SkpJU9h6kadLS0uDq6go+n48rV66o7fdfZRs/fjzu37+vli9yRHmo+IjaTZo0CRcvXsTGjRsxa9YslJeXq+R9+Hw+FixYQN/INUxERASGDBmCRYsWYefOnTA2NmYdqcl4PB4CAwNpG9MyNLmFMFNWVob58+fjxo0biIiIUMm3fpp2rjmqq6uxdOlSiEQiiEQi9OvXj3UkpXjy5Ans7e1x+/ZtWFlZsY5DGoBOZyDMGBgYYOLEiQCAd999F126dFH6FPaaaed37tyhaecMPXjwAOPGjUNxcTFOnTqltYc262JkZITs7GykpaWp9W4RpOloxEc0wtWrVzF58mRMmzYNq1atUurMvhs3bmDMmDH466+/YGBgoLTlkoY5f/48pk2bhvnz5+Orr75Sy+ks6nbr1i2MGDECOTk5tI1pAd3bAolWcnV1RWJiIpKSkjB69Gg8fPhQacvu0aMHHB0dadq5msnlcqxevRqTJ0/Gjh07sHz5cp0sPQDo1q0bnJ2dER4ezjoKaQDd3AqJVrKwsMCJEycwZMgQ9OvXD5cuXVLasmnauXqVlJTA19cXYWFhuHr1Kjw9PVlHUrmgoCCsW7dOpTOViXJQ8RGNwuPxsHLlSmzZsgWTJk1S2gfJuHHjkJ+fj7i4OCWkJK9y8+ZN9O/fH23atMGFCxfUep1Wlry8vFBUVISrV6+yjkJeg4qPaCRvb2/ExsZi9+7dmDp1Kp49e/ZGy6Np5+oRGhoKDw8PfPXVV9i0aRMMDQ1ZR1Ib2sa0B01uIRpNLBZj4cKFuHjxIg4dOvRG92SrmXZ+69YttG3bVokpSWVlJT755BOcOnUKERER6NmzJ+tITDx9+hQdO3bEzZs30a5dO9ZxSD3odAai0fh8PsaPHw9jY2PMmDEDtra2cHZ2btKyjIyMkJOTg9TUVJp2rkS5ubnw8vKCXC7H8ePH9ebQZl2EQiFyc3Nx8+ZNvPXWW6zjkHrQiI9ojT///BO+vr4YN24cgoODmzRtvGbaeXZ2tl4dhlOVM2fO4N1338Unn3yCTz/9FBwOh3Uk5lJTUzF8+HDk5ORAKBSyjkPqQL/xEa3Rp08fJCQk4M6dO/Dw8MC9e/cavYxu3bqhR48eNO38DclkMqxatQozZ87EgQMH8Nlnn1Hp/c3JyQl9+vTBwYMHWUch9aDiI1qlRYsWOHLkCLy9vdG/f39ERkY2ehk07fzNPHnyBOPHj8fJkyeRkJBAh43rsGjRItrGNBgVH9E6XC4XX375JXbv3o0ZM2bg+++/h0wma/Drvby88OTJE8TGxqowpW5KSkqCi4sLunTpgqioKJrAUQ9PT0+UlpYq9VxUojxUfERrjRw5EvHx8Thy5AgmTpyI4uLiBr2Oy+XStPMm2L59Ozw9PfHDDz9gzZo1dNfxV+ByuVi4cCFtYxqKJrcQrVdVVYVPP/0Ux48fR0REBHr16vXa19RMO79x4wbat2+vhpTaq6KiAoGBgbhy5QoiIiLe6JQSfVJSUoKOHTvi2rVrsLGxYR2HvIBOZyBaj8fjYezYsbC0tMS0adPQpk0b9O7d+5WvEQqFyMvLw40bN2ja+StkZWXB09MTzZo1w7Fjx+hLQiMYGhriwYMHSE5OxogRI1jHIS+gER/RKSkpKfDx8cHw4cOxbt26V04nT0tLw7Bhw2jaeT2OHTuG999/H//+978RGBhIszabIDMzE25ubsjJyYGRkRHrOORv9Bsf0Sndu3dHXFwcHj9+jCFDhiA7O7ve5zo6OqJv3744cOCA+gJqAalUimXLliEgIACHDx/GwoULqfSayMHBAQMGDMC+fftYRyEvoOIjOsfc3BxhYWGYMWMGBg4ciJMnT9b73Jq7NujzgY+CggIEBQWhuroaBQUF8PT0RGxsLBITE+Hm5sY6ntajbUzzUPERncThcLB48WKEh4dj7ty5WLFiBaRSaa3neXp6oqysTK+nnX/33XcICQnBlClT4OLiAldXV5w+fRqtW7dmHU0njBo1ClVVVTh//jzrKORv9Bsf0Xn5+fmYOnUqhEIhQkND0apVq5ce37hxI2JiYrB5516IEvOQml+CErEE5kI+nKzM4edijVam2nV5s8LSygaty5MnT2BtbY3y8nIAwKeffooff/yRVWydtXnzZpw9e5ZuhqwhqPiIXpBIJPjyyy8RFhaG8PBw9O/fX/HYlbT78P2/n2Hi0B8cDgeVkv+dDC/kcyEH4O5oiYDhDuhl05xB+oZLzi1GSHQmYtILAOC167JkyRKsXr1aMRo2MDBAenq6Xl9oWhVKS0tha2uLxMRE2NnZsY6j9+h0BqIXuFwuRo0ahQ4dOmD69OkwNzeHi4sLQq/m4NNDKZCZtYFUzoFU9vL3QIlMDqlMjqzCMhy+dh/Njfjoaa2Z5bc3NhuLDl5D+qNnitwv+ue6mBvy8PncqZDL5TA1NYWLiwumTJmCt956i2YgKpmBgQEePXqExMREjBo1inUcvUcjPqJ30tPT4ePjA6shvsi1HABxdcMvd2Yk4GKZV1f4D7RTXcAm2BubjW+P30ZFI9flrZZP8cUkN9jY2NDMTRXLysrCgAEDkJOTAxMTE9Zx9BoVH9FLsRkPMLRfL0jLnwIcLjhcHgytu6Kl5wLwzS0Vzyu+EIqnl/bD6r2fYNjOEQBgJODh4LyBGjPyS84txtSfY1FR/b/JO3mb5kBWXgxw/jd/zbTHCLQc/eFLr9W0ddF1EyZMgJeXF+bNm8c6il6jWZ1EL+2IvQc5hwNL3+Xo8IkI1gv3gGvcHI/PbFU8Ry6XoywlClyhGUpv/u8uEGKJFJuiM1nErlNIdCbEktozVmvWreY//yw9QPPWRdfRqQ2agYqP6J3C0srnkz9e+Ozh8A1g4jQY1YV3FX+rzE2BtPQxWoych/Jb5yGXVgMA5HIgKq0ARaWV6o5eS826NPVzVJPWRR94eHgAQJNup0WUh4qP6B1RYl6tv8mqxSi7fUFxOBMASm+eg5HDAJh0HQoAqMiMVzzGASBKqr0cdatrXRpLU9ZFH3A4HMWoj7DDZx2AEHVLzS9RTPMviFgFcHmQV1WAZ9IcrSevBPC8CMtTL8Li7Y/B4fFh7DQYpTfOwdjx+ZVMxBIZUh88Y7YONV5cl3+qWbcaLTxmw6z3mFrP05R10Rf+/v5YtmwZsrKyYG9vzzqOXqLiI3qnRCxR/HdLn69gZNcbcpkUFRlX8XDfErSbuxkVOdfA4fJg1KkfAMCkmzseHvgK0vKn4Bk3+3s51Uzyv+jFdfmnmnVr2HLYr4u+MDY2xpw5c7Bx40asWbOGdRy9RIc6id4xF9b+vsfh8p6P5jhciPNSUHYjErIqMfI2zUbuBn8UHP4ekElQdivmheWwvxFrXevStOWwXxd9EhAQgF9//RWlpaWso+glGvERveNkZQ5Dfv5Lf5PL5ajIuAqZuBQ805YQ5ySj9eQVMLDsqHhOScIRlN04B/N+4yHkc+HU1kzd0WupWZf6Dnc2hKasiz6xtbWFu7s7du/ejYCAANZx9A4VH9E7vi7WWHs2HQBQIFr5/FxsZJKPAAAgAElEQVQ3Dgd8c0u0ensxKnNTYNC6I4w69n3pdWYu41AS9xuqCrJh2NYevn2tWcR/yYvr8k+Kdfub0K43Wvt8Vet5ckAj1kXfLFq0CPPnz8cHH3wALpcOvqkTncBO9NK8PQk4c/thk04D4HAAz25tsMW/n/KDNYEurYs+kcvl6NOnD4KDgzF69GjWcfQKfc0geuHZs2c4f/481qxZg549e6JN4TUI+bzXv7AOQj4PAe4OSk7YdAvcHXRmXfRJzakN69atYx1F79CIj+i8UaNGISYmBkKhEKWlpZDL5YiMjMQ9o45Nur6lLl2rUxPXRZ9UVFTA1tYWly5dQufOnVnH0Rs04iM6b9KkSeDxeHj27Bnkcjnc3d3h4eEB/4F2WObVFUYCHl53fWYO5/l1LTW1KHRpXfSJkZER5s6di40bN7KOoldoxEd0mlwuxy+//ILAwEDI5XIIBAJERkbC1dVV8ZzrecXYFJ2JqLQCcPD8hO4aNfew83C0RIC7g8ZfzFmX1kVf5OXloWfPnsjOzoa5uTnrOHqBio/orIqKCixYsABXr15FaGgofH19YWFhgdjY2DqfX1RaCVFSHlIfPEOJuBrmQgGc2prBt6/23YFdl9ZFH0yZMgWDBw9GUFAQ6yh6gYqP6KQ7d+7Ax8cH3bp1w7Zt22BqaoqCggJIpVJYWVmxjkfISy5duoRZs2YhLS2NTm1QA/oXJjrn2LFjGDRoEObOnYvQ0FCYmpoCACwtLan0iEZyc3ODubk5Tp48yTqKXqARH9EZEokEy5cvx969e3Hw4EEMGjSIdSRCGmz37t3Yt28flZ8aUPERnfDo0SNMmzYNHA4H+/fvh6Wl5etfRIgGqayshK2tLaKjo+Hk5MQ6jk6jQ51E6125cgUuLi4YNGgQTp06RaVHtJKhoSHmzZuHDRs2sI6i82jER7SWXC7Hxo0b8c0332D79u0YN24c60iEvJH79+/D2dkZWVlZaN6cTjdRFSo+opVKS0vxr3/9C6mpqYiIiKAbehKdMWPGDPTr1w+LFy9mHUVn0aFOonVSU1MxYMAAGBsb4/Lly1R6RKcEBQVh48aNkEqlrKPoLCo+olXCw8MxdOhQfPLJJ9i+fTuMjIxYRyJEqVxdXWFhYYE//viDdRSdRYc6iVaorq7GF198gcOHD0MkEqFv376vfxEhWio0NBQ7d+7E2bNnWUfRSVR8ROPdv38fkydPRvPmzbF79260bNmSdSRCVKqqqgp2dnY4c+YMunfvzjqOzqFDnUSjRUdHo1+/fhgzZgyOHj1KpUf0goGBAT744AM6tUFFaMRHNJJcLsfq1avx008/Yc+ePRg1ahTrSISo1cOHD+Hk5IQ7d+7QFz4loxEf0ThPnz7FpEmTIBKJEBcXR6VH9FKbNm0wbtw4bN++nXUUnUPFRzTK9evX0a9fP7Rv3x7nz59Hhw4dWEcihJmgoCCEhIRAIpGwjqJTqPiIxtizZw9GjBiBFStWYOPGjTA0pPvGEf1W8yXw2LFjrKPoFPqNjzBXWVmJjz76COfOnUNERAR69OjBOhIhGuPgwYPYvHkzoqOjWUfRGTTiI0zl5ORg6NChePToERISEqj0CPmHSZMmITMzE8nJyayj6AwqPsLMqVOn4OrqiilTpkAkEsHc3Jx1JEI0jkAgwIcffkinNigRHeokaieTybBq1Sps3boV+/btw/Dhw1lHIkSjFRQUoEuXLsjIyICFhQXrOFqPRnxErYqKivD222/j7NmzSEhIoNIjpAEsLS0xceJE/Pzzz6yj6AQqPqI2iYmJ6NevH7p164Zz586hbdu2rCMRojUWLlyITZs2obq6mnUUrUfFR1ROLpfj559/xtixY/Hjjz9i9erVEAgErGMRolX69OmDjh074vDhw6yjaD36jY+oVHl5ORYsWID4+HhERETA0dGRdSRCtJZIJMJ///tfXLx4kXUUrUYjPqIymZmZcHNzQ1VVFa5evUqlR8gbmjBhAu7evYukpCTWUbQaFR9RiaNHj8LNzQ3/+te/sHfvXpiYmLCORIjW4/P5WLBgAdavX886ilajQ51EqSQSCZYvX469e/ciLCwMAwcOZB2JEJ1SVFQEBwcHpKWloXXr1qzjaCUa8RGlefToETw9PREfH4/ExEQqPUJUoFWrVvD19cW2bdtYR9FaVHxEKS5fvgwXFxcMGjQIJ0+ehKWlJetIhOisoKAgbN68mU5taCIqPvJG5HI51q9fj4kTJ2Lz5s1YtWoVeDwe61iE6LQePXrA0dERIpGIdRStRL/xkSYrLS3F3LlzkZ6eDpFIBHt7e9aRCNEbhw8fxg8//IArV66wjqJ1aMRHmiQ1NRUDBgyAqakpLl26RKVHiJqNGzcO+fn5iIuLYx1F61DxkUYLCwvD0KFD8cknn+CXX36BkZER60iE6B0ej4fAwEC6a0MT0KFO0mDV1dX4/PPPceTIEYhEIvTt25d1JEL02pMnT2Bvb49bt27RtW8bgUZ8pEHu3bsHDw8PZGRkIDExkUqPEA3QokULTJ06FVu3bmUdRatQ8ZHXioqKQv/+/TF27FgcPXoULVq0YB2JEPK3hQsXYuvWraisrGQdRWtQ8ZF6yeVyBAcHY/r06fj111+xbNkycLm0yRCiSbp164YePXogPDycdRStQb/xkTo9ffoUs2bNwoMHDxAeHg4bGxvWkQgh9fj999/x9ddfIy4uDhwOh3UcjUdf30kt169fR79+/WBtbY3z589T6RGi4by8vPDkyRPExsayjqIVqPjIS/bs2YMRI0ZgxYoV2LBhAwwMDFhHIoS8BpfLRWBgIN21oYHoUCcBAFRWVuKjjz5CZGQkIiIi4OzszDqSTiosrYQoMQ+p+SUoEUtgLuTDycocfi7WaGVqyDoe0WJPnz5Fx44dcePGDbRv3551HI1GxUeQk5MDX19f2NraYseOHTA3N2cdSeck5xYjJDoTMekFAIBKiUzxmJDPhRyAu6MlAoY7oJdNc0YpibZbuHAhmjVrhlWrVrGOotGo+PTcqVOnMHPmTHz22Wf4+OOP6YdxFdgbm41vj6dCLJHiVXsbhwMI+Tws83KC/0A7teUjuiMtLQ3Dhg1DTk4OhEIh6zgai37j01MymQxff/015syZg7CwMHzyySdUeirwvPRuo6L61aUHAHI5UFEtxbfHb2NvbLZa8hHd4ujoiL59++LAgQOso2g0GvHpoaKiIvj7+6OsrAwHDx6kSx2pSHJuMab+HIuKammtx8pSolESfxjVRXngGhhB0MYezQZNhtCmOwDASMDDwXkD0dOaDnuSxjl58iS+/PJLJCYm0pfZetCIT88kJCTAxcUFzs7OOHfuHJWeCoVEZ0IsqV16JXG/4fG5n9Fs0GRYL9yL9gE7YdbHCxUZVxXPEUuk2BSdqc64REeMHj0aZWVluHTpEusoGouKT0/I5XJs27YNXl5e+Omnn/Djjz9CIBCwjqWzCksrEZNeUOvwpkxchuILoWg5+kMYO7qBayAEh8eHcWdXtHhrjuJ5cjkQlVaAolK6DBVpHC6Xi4ULF2LdunWso2gsKj49UF5ejtmzZ2PDhg24ePEifHx8WEfSeaLEvDr/Xnk/FXJJFYy7DHrtMjgAREl1L4eQV5k5cybOnTuHu3fvso6ikaj4dFxmZiYGDRoEiUSC2NhYdOnShXUkvZCaX/LSKQs1pBUl4Bqbg8PlvXYZYokMqQ+eqSIe0XFmZmZ47733sHnzZtZRNBIVnw47cuQI3NzcMH/+fOzZswcmJiasI+mNErGkzr/zjMwhKy+BXFb7t7+6l1OtzFhEjwQGBuKXX35BRUUF6ygah4pPB0kkEixduhRBQUE4duwYAgICaHaXmpkL+XX+3bCdEzh8A5SnX2ngcl7+HVYmqz2KJKQuDg4OGDhwIEJDQ1lH0ThUfDrm4cOHGD16NBITE5GQkABXV1fWkfSSk5U5DPm1dy+u0ATNh87A49NbUJ5+BbJqMeRSCSruJOBJ1I6Xnivkc3En6Txmz56NoUOHol27djAwMMDvv/+urtUgWi4oKAjr168HnbX2MjqPT4dcvnwZU6ZMwcyZM/H111+Dx3v970hENQpLKzH4h8g6f+cDgNKUKDyLP4LqolxwDIxgaOUA80FTILTuqniOIZ+LJ78GoiA3S/E3gUCAu3fvwsrKSuXrQLSfXC5H9+7dsWnTJri7u7OOozGo+HSAXC7Hhg0b8O2332LHjh3w9vZmHYkAmLcnAWduP3ztFVvqwuEAnt3aIHh8FwwePBipqamQSCTg8XgYOHAg/Pz84OvrSxcjJq+1ZcsWnD59GocOHWIdRWNQ8Wm50tJSzJ07F+np6YiIiEDHjh1ZRyJ/e9WVW17nxSu3lJSUYOjQoUhJSUFwcDAcHR0RHh6Oo0ePomvXrooStLa2VsFaEG1XVlYGW1tbJCQkwM7OjnUcjUC/8Wmx27dvY8CAATAzM8Ply5ep9DRML5vmWOblBCNB43YzIwEXy7ycFJcrMzc3x4ULFzBjxgz4+/vD29sbu3btQn5+PpYtW4bk5GT06tULbm5uWLt2LXJzc1WxOkRLmZiYYNasWQgJCWEdRWPQiE9LhYWFYcGCBfjhhx8wZ86c17+AMKOOuzNUVVXh3LlzEIlEOHLkCDp37qwYCXbo0OHNVoBovb/++gv9+/dHTk4OndYEKj6tU1VVhc8//xxHjx5FREQE+vTpwzoSaYDrecXYFJ2JqLQCcPD85PQaNffj83C0RIC7wxtfmLq6uhqRkZEIDw/H4cOH0alTJ0UJ0qEu/TVx4kSMGTMG8+fPZx2FOSo+LXLv3j1MnjwZLVu2xO7du9GiRQvWkUgjFZVWQpSUh9QHz1Airoa5UACntmbw7auaO7BXV1cjKipKUYIdO3aEn58f/Pz8qAT1TFRUFAIDA3Hz5k29P6+Xik9LREVFYcaMGQgMDMSSJUvA5dLPs6RxqqurER0djfDwcPz222+ws7NTlCD9Pqz75HI5evbsibVr12LkyJGs4zBFxafh5HI5goOD8d///hd79uzR+w2WKIdEInmpBDt06KAoQXt7e9bxiIr8/PPPOHbsGI4ePco6ClNUfBqsuLgYs2bNwsOHDxEWFgYbGxvWkYgOkkgkiImJgUgkwqFDh9C+fXtFCTo4OLCOR5SovLwctra2iI2NRadOnVjHYYaKT0MlJyfDx8cHXl5eWL16NQwMDFhHInpAKpXi/PnzCA8Px6FDh9C2bVtFCXbu3Jl1PKIES5YsQWVlJdauXcs6CjNUfBro119/xaeffop169Zh+vTprOMQPSWVSnHhwgWEh4cjIiICVlZWihKk21tpr7t376JPnz7Izs6GmZkZ6zhMUPFpELFYjI8++ghRUVE4dOgQunfvzjoSIQCel+DFixcVJdi6dWtFCTo6OrKORxrJ19cXHh4eWLBgAesoTFDxaYjs7GzFFPPt27fD3NycdSRC6iSVSnHp0iVFCVpYWChK0MnJiXU80gAXLlzAv/71L9y6dUsvZ4jr3xproJMnT8LV1RXTpk1DWFgYlR7RaDweD8OGDcOGDRuQl5eHkJAQFBQUYMSIEXB2dsbXX3+NW7dusY5JXmHIkCEwMjLC6dOnWUdhgkZ8DMlkMnzzzTfYtm0bDhw4gKFDh7KOREiTyWQyXLlyBeHh4RCJRGjWrJliJEiH7TXPzp07ER4ejuPHj7OOonZUfIwUFRXB398f5eXlOHjwIN1fjegUmUyG2NhYRQmamZm9VIL6fuUQTSAWi2Fra4sLFy7o3WQlKj4G4uPj4efnh8mTJ+M///kP+Hw+60iEqIxMJsPVq1cVJWhiYqIoQWdnZypBhr766iuUlJRg/fr1rKOoFRWfGsnlcmzbtg3//ve/sWXLFkyaNIl1JELUSiaTIS4uTlGCRkZGihLs0aMHlaCa3bt3Dz169EB2drZezS2g4lOT8vJyfPjhh0hKSkJERITeHVog5J/kcjni4+MRHh6O8PBwGBoawtfXF35+fujVqxeVoJpMnToVgwYNwqJFi1hHURsqPjXIyMiAr68vevbsiS1bttD9sAj5B7lcjoSEBEUJ8vl8xUiwd+/eVIIqdPnyZbz33ntIT0/Xm1Mb9GMtGTpy5AgGDx6MDz74ALt376bSI6QOHA4H/fv3R3BwMLKysrB//35IpVL4+PigS5cuWLp0KZKSkkDf05Vv0KBBaN68OU6cOME6itrQiE9FJBIJvvrqK+zfvx9hYWFwdXVlHYkQrSOXy5GUlKQYCQJQjAT79u1LI0El2bNnD/bu3YtTp06xjqIWVHwq8PDhQ0ydOhUCgQD79u2DhYUF60iEaD25XI4///xTUYIymUxRgi4uLlSCb6CyshK2traIiopC165dWcdROTrUqWSXLl2Ci4sLhg0bhhMnTlDpEaIkHA4Hffv2xXfffYeMjAwcOnQIfD4f06dPh729PT777DPExcXR4dAmMDQ0xPz587FhwwbWUdSCRnxKIpfLsW7dOnz33XfYuXMnvLy8WEciRC/I5XJcv35dMRKsrKxUzA4dMGAAjQQb6MGDB+jWrRv++usvNG/enHUclaLiU4Jnz55h7ty5yMzMhEgkQseOHVlHIkQvyeVy3LhxQ1GCFRUVihJ0dXWlEnwNf39/9O3bFx9//DHrKCpFxfeGbt26BR8fHwwdOhTr16+HUChkHYkQguclePPmTUUJlpWVvVSC+jJ1vzHi4uIwZcoUZGZmgsfjsY6jMlR8b+DgwYMIDAxEcHAwZs+ezToOIaQecrkcKSkpiivGlJSUwMfHB35+fhg0aBCV4AsGDhyIpUuX4p133mEdRWWo+JqgqqoKn3/+OY4dOwaRSIQ+ffqwjkQIaYRbt24pRoLFxcWKEnRzc9P7Ety3bx+2b9+Oc+fOsY6iMlR8jXTv3j1MnjwZrVq1wq+//ooWLVqwjkQIeQO3b99WlODjx48VJTh48GC9LMGqqirY2dnh9OnTcHZ2Zh1HJaj4GiEyMhL+/v5YuHAhvvjiC73cKQjRZampqYoSLCwsfKkEdfk3r3/65ptvkJubi23btrGOohJUfA0gk8kQHByMdevWYe/evRgxYgTrSIQQFUtLS1OU4KNHjxQlOGTIEJ0vwYcPH8LJyQmZmZlo1aoV6zhKR8X3GsXFxZg5cyYePXqE8PBwWFtbs45ECFGz9PR0RQnm5+dj0qRJ8PPzw7Bhw3S2BGfOnInu3bvj888/Zx1F6aj4XuHatWvw9fWFl5cXVq9eDQMDA9aRCCGMZWRkQCQSITw8HPfu3XupBHXpptKJiYmYNGkS7ty5o1PrBVDx1WvXrl347LPPsH79ekybNo11HEKIBqq5aEV4eDjy8vIwceJE+Pn5Yfjw4TpRFkOGDMHixYvh4+PDOopSUfH9g1gsRlBQEM6fP4+IiAh0796ddSRCiBa4c+eOogTv3r2rKEF3d3etLcGwsDCEhIQgJiaGdRSlouJ7QXZ2Nnx9fdGxY0fs2LEDZmZmrCMRQrRQVlaWogSzs7MxceJE+Pr6wsPDAwKBgHW8Bquuroa9vT2OHTuG3r17s46jNFR8fztx4gRmzZqFpUuXYtGiRXRNP0KIUmRnZytK8M6dO5gwYQL8/Pzw1ltvaUUJfvfdd8jMzMT27dtZR1EavS8+qVSKlStXYvv27Thw4ACGDBnCOhIhREfl5OQoSjAzMxPvvPMO/Pz8MGLECI0twcLCQnTu3Bnp6emwtLRkHUcp9Lr4CgsL4e/vD7FYjAMHDsDKyop1JEKInrh7966iBNPT018qQU2bQf7++++jU6dO+PLLL1lHUQq9Lb74+Hj4+flhypQp+Pbbb7X2x2dCiPbLzc1VlGBaWhrGjx8PPz8/jBw5UiNK8Nq1a3j77bfx119/aezItDH0rvjkcjm2bt2K5cuXY+vWrZg4cSLrSIQQopCbm4uIiAiEh4fj9u3bGD9+PHx9fTFq1CgYGhoyyzV8+HAsWLAAkydPZpZBWfSq+MrLy/HBBx/gzz//REREBLp06cI6EiGE1OvevXuKEkxJScHbb78NPz8/jB49Wu0leOjQIaxZswYXL15U6/uqgt4UX0ZGBnx8fNCrVy9s2bIFJiYmrCMRQkiD3b9/X1GCN27ceKkE1XEDbIlEgk6dOuHQoUNwcXFR+fupkl4U3+HDhzFv3jysXLkS8+fPp1MVCCFa7f79+zh06BDCw8Nx/fp1eHt7w8/PD56eniotweDgYKSkpODXX39V2Xuog04Xn0QiwbJly3DgwAGEh4djwIABrCMRQohSPXjwQFGCycnJ8PLyUpSgkZGRUt/r8ePH6NSpE1JTU9GmTRulLludtKb4CksrIUrMQ2p+CUrEEpgL+XCyMoefizVamdY+1p2fn49p06bBwMAAoaGhsLCwYJCaEELUJz8/H7/99hvCw8ORlJQELy8v+Pr6YuzYsUorwfnz58Pa2hofLv68UZ/JmkTjiy85txgh0ZmISS8AAFRKZIrHhHwu5ADcHS0RMNwBvWyaAwAuXryIqVOn4v3338fy5ct19rYhhBBSn4cPHypKMDExEWPGjIGfnx/Gjh0LY2PjJi/3UEwiFm09DqNO/cBBwz6TNY1GF9/e2Gx8ezwVYokUr0rJ4QBCPg9fjnVCYexv+P7777Fz5054eXmpLywhhGioR48eKUowPj5eUYJeXl6NKsGaz+SKqmqAw633eTWfycu8nOA/0E4Ja6BcGlt8z/+Bb6OiWvb6J/+NK5PAKO0E/vjvEtjZ2akuHCGEaKmCggJFCcbFxcHT01NRgq+a7d6Uz2QjARfLvLpqXPmptfj27duHNWvWIDU1FWZmZujduzeWLVuGs2fP4ttvv1WclyKTA5VSwGbxQQBAzvdvgyMwBMABhyeAQZuOMO09BiZdhymWnR+6BJX308Dh8mAiFKBP794ICQlBjx49Xsqwa9cuzJ49GwcPHtSJEzEJIaSpCgsLFSV49epVjB49WlGCpqamis/sW7dTUcU1gKC1PZoNmgxx9jU8vRIGDu+Fq7hweehQ12c2X4B+ffvg44UBmDJlCpsV/Qe1Fd+aNWvw/fffY8uWLfD09ISBgQFOnjyJ8+fPw8TEBJmZmdi7dy8AYN6eBJy5/VBxeDPn+7fRbv42CFq0g7T8KSqyEvHk3C8wc3kbzYdMB/C8+EycPWDe2xOjHFvB6s5xHD16FNeuXXsph4eHB65fv46BAwfijz/+UMeqE0KIxissLMSRI0cQHh6OK1euwNbWFjk5Odi0aRPOVnRAVMZjlN9JRGVuCjgCQ0iKH8Bi3Kd1LuvFz2xZxVM4iDNxI2IDAgMD8X//939qXrPa6j9Iq0RPnz7F8uXLERISgkmTJsHExAQCgQDjxo3Djz/++NJzC0srEZNeUO9vejzjZjB1fgstPQPw9Eo4pBUlLz0ulwMxmU8wZvwk3Lp166XHcnJyEBMTg23btuHUqVN4+PChUteTEEK0FYfDwYQJE3Dy5Elcu3YN6enpsLe3x4JPliA64zHA5cO4sytavDWnUcvlGjXDPcv+CF67Ht999x2KiopUtAaNyKSON7ly5QrEYnGDrospSsxr0DKNOw8EZFJU3U+v/aC0Gt+s24aBAwe+9Ofdu3ejX79+8PHxQdeuXREaGtqg9yKEEF23YsUKtG3bFh999BHi4uIgkUgQHx+P5TuPg8d7s6rgAKho1wcSiQRxcXHKCfwG1HJLgqKiIlhYWLzyDghhYWH4/fffUVEtRbVUDoM29rCa/l29z+fw+OAam0Mqfqb425Mz2/Akcgfk1ZX4y8AA//nma0RGRioe37p1K9555x1ERkbC1dUVISEhOnVXYUIIaars7GxUV1dj06ZNCAkJAZ/PR0FBAe6WSCCR1y6+stsXUZ4Zr/jfr/rMFktkyCgQw8LCAo8fP1bZOjSUWoqvVatWKCwshEQiqbf8Jk+ejL1792LOr/GITH302mXKpRLIykvAE5op/tZi1DyY9fKEXC4D5/ZZLF26FH369IGpqSmKi4tx//59XLt2Dbdv34ZYLEZWVha++OILmJmZveKdCCFE96WmpgIAqqurATy/8tXhw4dRYtyvzuebdB1S7298dSkurUBBQQFatmz55mHfkFqKb9CgQRAKhTh8+DB8fX1f+VxzYcMilWfEAlwuDNrVvsMCh8PFxOmzcfH+ZUyePBmffvop5s2bh+TkZNy5c+eF53EwdOhQrFmzpnErRAghOmb+/PnYvn07DA0N8f7772PHjh2wtLSEuVQ5NVFw8yL4fL5GXDpSLcXXrFkzrFy5EgsWLACfz8fo0aMhEAhw9uxZREVFvXQCpZOVOQz5+S9dDeBF0opnqMhKwJNz29HM1Rc8I/NazxHyuTAoysCtW7fQvXt3iMVihIWFYdu2bfD29lY8LyIiAitXrkRwcDDdiJYQotc8PDzQrFkzfPHFF2jVqhXs7OywYMECTFz4NQTyNqiScSHOvgbx3evg8Bt+STJpxTNIs5Nw/vwOxbJZU+t5fKGhoVi7di1u374NMzMzuLi4YNmyZTh9+rTiPD45gIoqKQCg/Qe/gGfS/B/n8fEhaN0RZr08YdLdXbHsF8/jAwA7m3ZYGBiIxYsX48CBA1i8eDHu3r370t2DxWIxrK2tsWvXLrz99tvq+mcghBCtEBoaih9/WoPrN1PAMTCCoZUDzAdNgfivpNrn8aH+z2zDNvZYu/xjzJ8zk82K/INGXrnln+fxNQaHA3h2a4Mt/nUflyaEENI4uvaZrJbTGRprgbsDhPymXVhayOchwN1ByYkIIUR/6dpnskYWXy+b5ljm5QQjQePiPb8unBN6WmvmFcEJIUQb6dpnssbO6Ki5qGlj7s6gqVcCJ4QQbadLn8ka+Rvfi67nFWNTdCai0grAwfMTIWvU3PvJw9ESAe4OGvetghBCdI0ufCZrfPHVKCqthCgpD6kPnqFEXA1zoQBObc3g21fz7/ZLCD9AwGUAAACrSURBVCG6Rps/k7Wm+AghhBBl0MjJLYQQQoiqUPERQgjRK1R8hBBC9AoVHyGEEL1CxUcIIUSvUPERQgjRK1R8hBBC9AoVHyGEEL1CxUcIIUSvUPERQgjRK1R8hBBC9AoVHyGEEL1CxUcIIUSvUPERQgjRK1R8hBBC9AoVHyGEEL1CxUcIIUSvUPERQgjRK1R8hBBC9AoVHyGEEL1CxUcIIUSvUPERQgjRK/8P1lKjSjnTQcAAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import networkx as nx\n",
    "import heapq\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "import copy \n",
    "\n",
    "def huffmans_code(sigma, heap):\n",
    "    print(\"sigma {}, heap {}\\n\".format(sigma, heap))\n",
    "    if len(sigma) == 2:\n",
    "        T = nx.DiGraph()\n",
    "        meta_symbol = ''.join([sigma[0], sigma[1]])\n",
    "        T.add_weighted_edges_from([(meta_symbol, sigma[0], 0), (meta_symbol, sigma[1], 1)])\n",
    "        return T\n",
    "    #sigma_prime = copy.deepcopy(sigma)\n",
    "    smallest = heapq.heappop(heap)\n",
    "    smallest2 = heapq.heappop(heap)\n",
    "    meta_symbol = ''.join([smallest[1], smallest2[1]])\n",
    "    sigma.remove(smallest[1])\n",
    "    sigma.remove(smallest2[1])\n",
    "    sigma.append(meta_symbol)\n",
    "    p_ab = smallest[0] + smallest2[0]\n",
    "    heapq.heappush(heap,[p_ab, meta_symbol])\n",
    "    T = huffmans_code(sigma, heap)\n",
    "    T.add_weighted_edges_from([(meta_symbol, smallest[1], 0), (meta_symbol, smallest2[1], 1)])\n",
    "    return T\n",
    "    \n",
    "    \n",
    "def huffmans_code_heap(sigma, weight):\n",
    "    input_dict = {sigma[i] : weight[i] for i in range(len(sigma))}\n",
    "    heap = [[value, key] for key,value in input_dict.items()]\n",
    "    heapq.heapify(heap)\n",
    "    T = huffmans_code(sigma, heap)\n",
    "    nx.draw_planar(T, with_labels = True)\n",
    "    roots = (v for v, d in T.in_degree() if d == 0)\n",
    "    leaves = [v for v, d in T.out_degree() if d == 0]\n",
    "    all_paths = []\n",
    "    for root in roots:\n",
    "        paths = nx.all_simple_paths(T, root, leaves)\n",
    "        for path in paths:\n",
    "            pathcode = ''\n",
    "            for i in range(len(list(path))-1):\n",
    "                pathcode += str(T[path[i]][path[i+1]]['weight'])\n",
    "            all_paths.extend([[path, {'weight': pathcode}]])\n",
    "    print(all_paths)\n",
    "    return all_paths\n",
    "\n",
    "\n",
    "#huffmans_code_heap(['A', 'B'], [3, 2])\n",
    "#output = huffmans_code_heap(['A', 'B', 'C', 'D', 'E', 'F'], [3, 2, 6, 8, 2, 6])\n",
    "#output = huffmans_code_heap(['A', 'B', 'C', 'D', 'E'], [0.32, 0.25, 0.2, 0.18, 0.05])\n",
    "output = huffmans_code_heap(['A', 'B', 'C', 'D', 'E'], [0.28, 0.27, 0.2, 0.15, 0.1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sigma ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L'], heap [[2, 'B'], [2, 'E'], [6, 'C'], [4, 'I'], [3, 'A'], [6, 'F'], [7, 'G'], [8, 'H'], [8, 'D'], [5, 'J'], [8, 'K'], [10, 'L']]\n",
      "\n",
      "sigma ['A', 'C', 'D', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'BE'], heap [[3, 'A'], [4, 'BE'], [6, 'C'], [8, 'D'], [4, 'I'], [6, 'F'], [7, 'G'], [8, 'H'], [8, 'K'], [10, 'L'], [5, 'J']]\n",
      "\n",
      "sigma ['C', 'D', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'ABE'], heap [[4, 'I'], [5, 'J'], [6, 'C'], [8, 'D'], [7, 'ABE'], [6, 'F'], [7, 'G'], [8, 'H'], [8, 'K'], [10, 'L']]\n",
      "\n",
      "sigma ['C', 'D', 'F', 'G', 'H', 'K', 'L', 'ABE', 'IJ'], heap [[6, 'C'], [7, 'ABE'], [6, 'F'], [8, 'D'], [10, 'L'], [8, 'K'], [7, 'G'], [8, 'H'], [9, 'IJ']]\n",
      "\n",
      "sigma ['D', 'G', 'H', 'K', 'L', 'ABE', 'IJ', 'CF'], heap [[7, 'ABE'], [8, 'D'], [7, 'G'], [8, 'H'], [10, 'L'], [8, 'K'], [9, 'IJ'], [12, 'CF']]\n",
      "\n",
      "sigma ['D', 'H', 'K', 'L', 'IJ', 'CF', 'ABEG'], heap [[8, 'D'], [8, 'H'], [8, 'K'], [9, 'IJ'], [10, 'L'], [12, 'CF'], [14, 'ABEG']]\n",
      "\n",
      "sigma ['K', 'L', 'IJ', 'CF', 'ABEG', 'DH'], heap [[8, 'K'], [9, 'IJ'], [12, 'CF'], [14, 'ABEG'], [10, 'L'], [16, 'DH']]\n",
      "\n",
      "sigma ['L', 'CF', 'ABEG', 'DH', 'KIJ'], heap [[10, 'L'], [14, 'ABEG'], [12, 'CF'], [16, 'DH'], [17, 'KIJ']]\n",
      "\n",
      "sigma ['ABEG', 'DH', 'KIJ', 'LCF'], heap [[14, 'ABEG'], [16, 'DH'], [17, 'KIJ'], [22, 'LCF']]\n",
      "\n",
      "sigma ['KIJ', 'LCF', 'ABEGDH'], heap [[17, 'KIJ'], [22, 'LCF'], [30, 'ABEGDH']]\n",
      "\n",
      "sigma ['ABEGDH', 'KIJLCF'], heap [[30, 'ABEGDH'], [39, 'KIJLCF']]\n",
      "\n",
      "[[['ABEGDHKIJLCF', 'ABEGDH', 'ABEG', 'ABE', 'A'], {'weight': '0000'}], [['ABEGDHKIJLCF', 'ABEGDH', 'ABEG', 'ABE', 'BE', 'B'], {'weight': '00010'}], [['ABEGDHKIJLCF', 'ABEGDH', 'ABEG', 'ABE', 'BE', 'E'], {'weight': '00011'}], [['ABEGDHKIJLCF', 'ABEGDH', 'ABEG', 'G'], {'weight': '001'}], [['ABEGDHKIJLCF', 'ABEGDH', 'DH', 'D'], {'weight': '010'}], [['ABEGDHKIJLCF', 'ABEGDH', 'DH', 'H'], {'weight': '011'}], [['ABEGDHKIJLCF', 'KIJLCF', 'KIJ', 'K'], {'weight': '100'}], [['ABEGDHKIJLCF', 'KIJLCF', 'KIJ', 'IJ', 'I'], {'weight': '1010'}], [['ABEGDHKIJLCF', 'KIJLCF', 'KIJ', 'IJ', 'J'], {'weight': '1011'}], [['ABEGDHKIJLCF', 'KIJLCF', 'LCF', 'L'], {'weight': '110'}], [['ABEGDHKIJLCF', 'KIJLCF', 'LCF', 'CF', 'C'], {'weight': '1110'}], [['ABEGDHKIJLCF', 'KIJLCF', 'LCF', 'CF', 'F'], {'weight': '1111'}]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "output = huffmans_code_heap(['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L'], [3, 2, 6, 8, 2, 6, 7, 8, 4, 5, 8, 10])\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Challenge problem\n",
    "In this programming problem and the next you'll code up the greedy algorithm from the lectures on Huffman coding.\n",
    "\n",
    "Download the text file below: huffman.txt\n",
    "\n",
    "This file describes an instance of the problem. It has the following format:\n",
    "\n",
    "[number_of_symbols]\n",
    "\n",
    "[weight of symbol #1]\n",
    "\n",
    "[weight of symbol #2]\n",
    "\n",
    "...\n",
    "\n",
    "For example, the third line of the file is \"6852892,\" indicating that the weight of the second symbol of the alphabet is 6852892. (We're using weights instead of frequencies, like in the \"A More Complex Example\" video.)\n",
    "\n",
    "Your task in this problem is to run the Huffman coding algorithm on this data set. What is the maximum length of a codeword in the resulting Huffman code? Continuing the previous problem, what is the minimum length of a codeword in your Huffman code?\n",
    "\n",
    "ADVICE: If you're not getting the correct answer, try debugging your algorithm using some small test cases.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/aishwaya/anaconda2/envs/python_3_6/lib/python3.6/site-packages/urllib3/connectionpool.py:847: InsecureRequestWarning: Unverified HTTPS request is being made. Adding certificate verification is strongly advised. See: https://urllib3.readthedocs.io/en/latest/advanced-usage.html#ssl-warnings\n",
      "  InsecureRequestWarning)\n",
      "IOPub data rate exceeded.\n",
      "The notebook server will temporarily stop sending output\n",
      "to the client in order to avoid crashing it.\n",
      "To change this limit, set the config variable\n",
      "`--NotebookApp.iopub_data_rate_limit`.\n",
      "\n",
      "Current values:\n",
      "NotebookApp.iopub_data_rate_limit=1000000.0 (bytes/sec)\n",
      "NotebookApp.rate_limit_window=3.0 (secs)\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAb4AAAEuCAYAAADx63eqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzsnXl4FFX2/t/ael/SSSedfYUQQpCwyU4iO8giAgrIIjKOsjgDP3AHxXEZBkUHdVRkFBTUERdmUVwYRNxAB8UFBEVEFEUUkCUQQpJ+f390upLOBvJFUft8nuc8SfetunXrVle9dc49dUshSQiCIAhClKCe6QYIgiAIws+JCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVYjwCYIgCFGFCJ8gCIIQVehnugGCIETy6Z7DuG3lFnz2fQlKj1fCbtHQJN6FWQOao0nAfaabJwi/ehSSPNONEAQBeHrDV5j38if47nBZg8skuK24qk8zDG+X9jO2TBB+W4jwCcIvgCueeA//+XD3SS8/6Kwk3DOqzU/YIkH47SLCF6X8msJpe0vK8PS7u7D120M4dKwCHpuOvEQPRrRNRZzL+out+2T5saIXRsRPEE4NEb4o49cUTvvgqwP426ufYe2n3wMAyiqCZplNV0EAxc3iMbmoCVqlxfxi6j4ZFEWp850Rn4nkifei4sAefP3ARAAKAAKKCnf7IYjtMREAsH/VAyj5YBVYUQZFVVFcVIRXXnnltLdREH6riPD9AvmxXsjJLv9rCqctW/8Fbl25FccqKtHYL1RRAJuu4foBeRjTMfOM1w0A27ZtQ8uWLTF8+HAsW7YMt912G2677TazvLKyEmVlZfjuu+/Q+/738Nmzf0XJ+y8Amg7dmwhbekuUvP8CEi+5B8GjB/Hd8hsBBqHooWPJ8mOwJOUiMPo2WPfvwOePXA2r1Qqr1YpRo0ZhwYIFMAwDALBlyxZMmTIF7777LuLj43H77bdj6NChJ70vgvBbRITvF0RjXoiqhLyE7k39mNYzF63SYszlX/3kewRJVASrD6WuKlAVBefkhbyWv7/x+a8mnBYSpi0oLQ+eeOEq7IaK6wc0P6FA/ZR1h+nTpw9KS0uRkZGBZcuW1SmfM2cOXnvtNTzwxL/Q56+v4ZvFf0D5d18gdeazqNizHd8uuxoIViD9qn9BUTVUHN6Hr/82HsmXLULloe+x54nrkDB6LuzpBdi/+u8o3fgckpOTsWHDBgwaNAh9+/bFTTfdhIqKCuTn5+Pyyy/HH//4R6xduxaDBg3Cxo0bkZube9L7Lwi/NUT4fiGYXkh5JU50QFQF6JITh3e++CFCHGvz3TM3o/Tzd4HKCkBRYU1rgcDIW3B89zbse/l+lH+3I+RJGFZ4u4yGt+MwAAAryrHnqRtR9uVHAAlvnB9vvLoGBQUFp3GP6zJmzBi89PJ/sf/gIahOHzwdh8Hdqi9KNq/B/hf/Vr0gCVaUIfHiv8Ka2AQH334GRz5ajcpD3yMxEI9pV0zFlVdeCQAoKyvD5MmT8d///hd79+1HpSsB3u7jYM9pF7HtA288joNvPI6EkbfAnllofl/6xfs4sGYxju/7EqgoR9euXfH666836MUtXLgQq1atwq5du/DRRx8BAFJSUnDddddh3LhxIInU1FTs3bsXQUVDZZBg+TEAgP+8a+HM64Jdf7sYlYf3hlxOAlpMAJUHvkX8+bNwdNt6HNn8KlS7B8Ej+wEAqm7A7XTgwIEDmDJlCu6//344HA4Eg0GUlpYCADZs2IC2bdsiJycHO3bsgMPhMNv+4YcfIjs7G3v37sWQIUOwdetWVFZWonnz5rjjjjvQpUuX03iUBeEXAIUzxscff8xzzjmHdqebhi+J8UOvY8Y1z0WYt+toAqARn0loBhXDRqhayAAqFjsd+edQdfoIRSEUlYrFTnvTjrQk5dKR15XO/GIqVmeonsSmhGEjFIW+npcy9f89RVtOe0JRqHkTqFjsVGwuAgrjz7+eqX94jJaYAN1uN5OTk+nxeFhUVMRNmzaZ+3Hs2DFOmDCBbrebgUCA8+fPJ0kWFRXRarXS6XTS6XQyNzeXJPnKK6+woKCAXq+XsbGxPO+887hr1y5u2rSJlzz0JlOnLKE1/SwCClWHl7F9J5v9kfqHx6jHJIX21eKgkZBFKApt2W2ZcdW/mNy8LQFEmKZp3LFjBycsep2qM6a6TNPpajeIyZctohGfQdXuoRHIoWpzUbV7aMtsTdXuZsKIObRlFjIhp4CDBw9mWVkZmzVrxpSUFLMPbrzxRnbt2pWxsbFMSEigqqr0eDzct28f169fz5iYGL755ptcu3YtnU4n9+7dS1/rPoTNbbYnfuh15vGuz2IHTDOPe20zDIMkuWzZMgLggQMH+OGHH9JqtTIrK4vBYJAkmZ2dzdTU1Hp/j6Wlpdy6dSsrKysZDAa5YsUK+nw+lpeX/yS/f0E4U8jMLT8Be0vK8MDa7Zj25EZc8sj/MO3JjXhg7XbsK6lOKKmoqMCQIUPQpmtPpE97Ar6+U7H3ufko3/+1uUz5D7tx9JM3obliAQCxfS5H+oyn4e10ASyJubCkNIcRl46jH6+Bt+MwJE9ajNjel0PRDOi+JJTv/RLBYyVgZTkCo/8M6BaU79kOzREDkHAV9oVmscPd9lyAhDOvG9KmL4dqcwEArCnNoTm8sGS0xuHDh/HCCy9g//796NSpE8aOHWu2c86cOdi2bRt27tyJNWvWYN68eXjxxRcBAPfeey9KSkpQUlKCTz75BACQn5+Pl156CQcOHMA333yDpk2bYtKkSQhkNMFrnx/A9/+ZD93jh+qMgefsoTiw9lEc2/khAEC12KHa3fB2Hon06U+GLvtQoNqcgKoBbYfD4XRi6tSpIInx48dj3LhxcPmTsPbT7+DI7Qzdl4K4IdcgtufvUbLhP/j+n3+Gr/hiQFFgz2mPlEkPI2Xywyj/4RsoVieCZUeg2lwoTz4LFrsDt99+OxISEsz9J4mlS5fi66+/RkxMDN555x3MmjUL3bp1g8PhQIcOHdCtWzesW7cOjzzyCIYPHw6bzQa4/FBYGdovZwz2Pn8Xjn/3BRSLHUZiLjR3HABAsYS8s+N7d0LRLICiwZLcDIoRHr9VoCgKvv32W9x9990AgKNHjyIvLw+KoiAnJwcVFRV4+eWX8cUXX6CysrLe363NZkOzZs2gqipIQtM0/PDDD9i/f/+PPQUE4ZfNGRbe3xR2h5O61U7FsIU8M0Wlu81AZlzzHLOnLiYA6lY77Q4n7XY7FUWhqld5cVDMu/fanwEQmkHVGUPFsFH3JdNIbBLy8qqWU+0eZlzzHK1pBQ16DAAIRSV0a+Rnm4sAmDJ5MZN/dz8Vq6O63OKg5oolFIUbNmzg5s2bmZ+fTwCMiYlhz549mZCQwJdeeokkOW/ePPr9fuq6TqvVymHDhkX00caNG9m1a1d6PB6mpKRw9uzZvOaaa+hwOKgbRkRbVbuH/vNnUbW5Qu1UVHN/vd3HMW7QTBqJTaqWV0JeIEBV03j//fezpKSELpeLr776Ku9/9TOmXLaQUHVCUZh86f2MKb64Vp+D7g7nM+Oa5+hs2atW34W8T6cnhqqqMikpibGxsSTJtWvX0mazUVEUfvzxx5wzZw4BsGfPniTJo0ePUtd1WiwWAqDNZqOmabQEsiOOn7kfho2+Hr9j+tX/CXnwDm/k8QIIw8aEkbcQmsWsQ1EUxsbGUtd1VlRU8IsvvqCiKMzMzKSqqtQ0jS6Xi4Zh0OfzMT8/n/n5+aZH7nQ6aRgGrVYrjapj4XK5aLPZzPLevXubx/KJJ55gbm4uPR4P4+PjOW7cOB48ePBnOtsE4dQR4TtNLF23g3mzX2DmtaGQXNr/e5qKYWNg9FxmXPMcUy5/iACYcfW/mDf7BRpWW11RUlVqbj+9xRMaF68GTTnF9UBApRFo0nAdispHH32Ub7zxBpOTk6nrOtMys5jdsR8BsOXVT7LLX1az7Yip7NL9HAJgs2bNqKoqXS4X7Xa7KQ6GYVBVVeq6boYiQ9tQzO1bUltQtbupxiRF7p+qhcQrop0KoelV31eFBeP8tLi8VYKoVpeFhaPBvquqq+ZytcKLMTHV4VKr1WruBwA6HI6IZcMi2bVrVy5dupR+v58ej6eBNoCB0XOp+pKrtmtEtk1RmTjxb9X7VKMPvD4fKyoqmJGRQQC02+2meGmaxk2bNrGsrIyqqprttNlstFgsfPzxx0mGhMxut9NqtdLv97Nbt26MjY3lqlWreOzYMV5yySVMT0+ny+ViYWEhH3nkEX7//fckyX379jEtLY1udyh0u2bNmojz45VXXmFxcTE9Hg8zMjJ+5rNTECKRUOdpoDpTsDo9/ugnb0JzeGFNaxGxLAmUllcia/oTAELPbvn6TgGgAMEgWHEcR7e8FlrY4oIlKTcUwgMAmxuOFj2hukIhMKi1Dx/rNs6o9fhDjefHbE06VtWjAwiifM/26joUFYpuhWJ1hsoZxLhx49C1a1ccLDmK5lf8HWUdLsHn76wCABysNLDrh1Lsjm2F9R9sBhQVXQaNxqWXXoqxY8fi/vvvh67rsFgs2LhxIzIyMvDQQw9h8ODB6NWrFwBAt3uQMOIGWFPzYU3IQrCiHCw9BMViBwBocSlQwn0BQvOnR+y37q0OPzrG3I1KxQj1napCj0mM6A9v0fjqZZt3R8LIW6r63A7NEQP/kKvCHQbF6oJSFf4FgI8//hj//e9/oes6FEWB3W6Hx+MBAHg8HowfP958Tq979+4giW+//RZ33XUXjh8/jj//+c/QdR2azQ1ohtkmR4tiWFObI1h6OLShYHnE/llT8lB56LvQZwYjjnfTdkX43//+h8rKSrRp0wYzZsxARkYG3G43CgsLkZWVhbvvvtts14cffojS0lLcdNNNePrppwEA6enpKCsrw5YtW7Bjxw6kpaXhwIED2L59OyoqKpCWloa1a9fi4MGDuPnmmzFlyhSUlJSYbQgEAmjRogUSExNRG6fTiUsuuQS33357nTJB+Nk508r7S6dmGMjpdFJVVU6dOtVM3LBaw2FJhbovmZo3EBmWUhRCqT8h4Sexn3hbiqoytv8fG9i2QtXupe5Pj/he13U6nU6mpKSwffv2DARCfaRUhSbDHpSiWwlNp2p3R3p0VnvkdqrCkjBqhGzDnlrtfjA9t/+LN1zXanptPp+PVmuoLZmZmbTZqr35mJgYbtu2zfx86623cvDgwSGv1x7p+SmGjYpuqdvn1lCoN7b/H6jHptQqrwpzqhpzc3O5bNky9urVi926daPdHuo3i8VCp9PJfv36mX3/z3/+kyQ5d+5cDh06lCR50003saioiCR5+PBhjh07loqi0Ov10u/3s3fv3nz//ffNc6Nly5a8+eabzb5wOBx86aWXmJKSUsfjC7Nq1Srx+IQzzm/O4zuZxJIfQzgxo6SkBG98+BlUw4pXy3Pw7s4fkNT7EpRDhf+8q5E+8xkYcWlgZQWgWwAAcedOQ9ygmVAsNgCAvVlX+EfcVOXBKVVWhaLV3fipwPoTF04XJE3vR7E6Qh4LUOUVEqrDA1tqC/Nha80bgOHwYO3atWjZsiWSk5Nx8OBBs67CwkI0b968qukVQGVFlccT8mYUmweKoiKir6rS/1WLHVDCP2ECqqXqfwWKxQYjLg32nLOry+ujan0l7EWb31cfD8UVB1gcEcW1E0T69u0LAMjKykKfPn2g66EXn/Tp0webNm1CYmIiDMNARUUF/v3vf6O8vBzBsiMRdWhuP2L7/xEAYARyzL5lWQmMhBy4WvZExQ+7Ad0CPS4NrvZDzf3yFRRj06ZNiI+Px9q1a/H5558jNzcXZ511FtxuN9566y08++yzZt+PGTMGHTp0wPz58zFkyBAAwIMPPoi0tDR4PB643W784x//gMViwbvvvoudO3finHPOQd++fXHgwAHs2bMHn376KYYPH46DBw9i165duPLKK5GZmVl/PwvCL4kzrbyni/e//IGXPvo/Nr1+JXOuez7ikYCc655n0+tX8vdL/0e7o34P7p577mHbtm1pGAY9Hg/tdjuLi4v56aefskOP/rTEVHlyqkZoFipWBx0tzqElOY+eDsOoWBz1egZ1TNEaGWf6lZhWa+yphlmz21Jz+qoTaLSQB6PqBpUa+63pBtMzMpmXl2d6frVNsXsiE3FqmqpT9SSc+j6okYk0enym+b8Rn8m0//dUg+tarVa2bNky4rvw2BlQd5yvpjkcDiYlJfG1t9+tfxmjnrHf8Dbc8TU+199nnTt35siRI00vL+yNhr3unJwcKopCm81Gv99Pt9vNH374ga+//jptNhsLCgrocrno9XqZkZHBZcuWRZxnzZo147PPPsuePXvy97//fUTZunXr2Lp1a/H4hF88vwnhW7puB3NnrazzDFx9ljtrJZeu20GSLCkpodPp5Nq1a/nMM8/wkUceoWEYLCoqYmlpKWfOnMmY1CbU41LNrD/V6aMtu62ZQVjzQmRvXnTmRUnshOJwOiws1uGEnfD3qqo2KORAKOyo6zoNS8MCd6qmqmqEAAOhJBdN09izZ0/m5+fznnvuodVqZV5eHp1OJ202G++9917+7ne/49ixY3ns2DFOmzaNSUlJdLlc9Pv9PH78uHmuKYpiZog6HA7zxpEkly9fbvZNOBP0T3/6k7nulVdeSb/fT0VRmJ6ezltuucUs++STTzh48GD6/X76fD726dOHW7duNcs/+ugj9unTh3FxcQTqXrbCN64Wi4Xjx48/zVcY4bfGrz7UuWz9F7jpuY8bncGkJmUVQdz03MdYtv4LPP300/DFxeOhz6y487MYzH7mPSh2L74oc2DskvfwDDriwNfbYcSmImnCglAFqoZgWSk0d3xVjQocLc4BNB2lW9YCmsXclh4n70wzqTMps1LVVwqUqufVYDhqrxUqtzobrFZrtI/5Ixt58rAqi+nYsWPo2LEjnM5QG8PJLjVpXdQP+cWDAQDHjx8HoSCny7nm83kmStV7oWv1ler2R3y2N+0A7zmXwJpRGPH9lVdeCUVRkBAIQFE15Hbuh2ELXoLNG4eYvI44Xl6OefPmgSQWLVqEAwcOwO124+abb8ZTTz2Fiy++GHPnzsWGDRuwadMmLFiwAPv378dNN92EY8eOYd68ebBYLOjUqRMOHz6Me+65B1arFcOHD8fOnTtxxx13AACSk5PxwgsvoKSkBLNnzzbbN3HiRCxevBjp6el466238Pjjj+PZZ58FABw4cACDBw/GJ598gj179uDss882Q7AAYBgGLrjgAjz00EP1Ho/k5GTMmjULl1xySf0HTBBqcqaV91QIp1YnpaRSsdhpJGTTmt4yFGKreoYulCABJlx4M21Zrc074MCo25hxzXP09fhd9Z2yzR3xPNSPD0X+dJ6F2K/cdAtdrfrS1X5ow8vUCruerCkWR/2/VauLUDUmjLyVzoIekWWKwoSkZB46dMh85jJcZrFYTG913LhxbNu2bUSijqIoVBSF119/PUly4MCB5neKopjJNCkpKXzppZf44YcfctCgQfT7/eYznw8++CDT09P52WefMScnh02bNq3Xi9u3bx8BsFWrVhFeXDhRiCQXLVrEnJwcOp1O9u3bl19//TWvv/56jh8/nnfddRezsrLodruZlJTEadOmmTPQ7Ny5s07SGgDecccdP99FTDij/GKEr77prS666CK6XC7zpLNareaJ2LRpU9piqk7a8MmvWwjdSlfbwdUZfrUvDIre8MWkkRCVmNgv35TIMVHNEpHlq8emUq3xMLyqqmY2av/+/XndddeZz/6pqmqOdwPgxo0bCYTE0XzuEmBsbCzfe+89kmRiYmKdNs2ePZv79u3jqlWr6pSpqsp58+bxn//8J4FIMQuPSz700EO8/PLLTTFLTU01t2u32/n++++zrKyMY8aMMdus67opwnfccQf37dvHc845h/379zefNbzwwgvNh+0///xzKopijoOGraKigiS5efNmtm3bljExMaaAb968+cxcKIXTwi8q1Fl7eqtrr70We/fuBUl8/PHHiImJwdixY1FcXIxxE3+PmHOvhKJb4MzvDiM+E/6BM5Ax8xlUHv4egALFsMGWWQjoVtiy2wGKCiM+HYACKAo0b+TzRo687ub/misWemxKI62t+z414TeG3dtIYcPHPyI0q9tOX3sAQG/45bjWjJZQDStQtX3/oBlQDAs0XxKgGbClFcCe3a7quU3gwf9+hOlXXg1FUXDQm4PduechtWUnaLqB/33wMb788kukpqYCAN555x2QxOuvv46FCxfigw8+gKqqGDVqFEaNGgUAWLt2LdLS0jB06FAsWbIEAPD2228jNjYWvXr1wr59+wAAS5YswfDhw9GyZUtcfvnlaNGihbn+ddddh4ULFyIuLg5FRUV45JFHEBcXCoUPGjQI//rXvwAAo0aNQmxsLFavXg2LxYK//OUvCAaDuPTSS3HRRRdh8+bNUFUVw4YNA0ns2bMH69atw5tvvolvvvkGpaWluOKKKwAAjz76KAKBAK6++uqILG5NC2X2Jicn4+mnn8b+/fuxd+9eDB48GCNHjjxth1Q4A5xh4TUpKiriokWLGizfunWreTfaoP3asyXFxE7VFLVGtm1dU6wuau74ulENVaPuDTC2/xV0tR5Q/eypptMdn8zhY6pnEQp7RbquMyEhgd27dzdDkuFwYVZWFr/66quIZxfDntWKFSuYmJhIkrz++uvZpk0bTp8+3Vx2xowZnDBhAps3b85bbrmFX3/9NQFw8uTJdUKdkyZNYkpKCidNmkSS3LVrFwFwxIgRHD9+POfMmcPmzZubM8lYLBZOmzbNvJ68+eabtFqtPHLkCLOzs9mlSxczhNsY5eXlvPfee2m320/1Uif8Ajgp4fvhhx84btw4xsfHMz4+njfeeGNEeUZGRoPz+V122WUR4QOLxWJmlTkcDrrdbiYk1E1L13WdU6dOjRiDqGsSmhQTOzlTasx3Wk9ZxN9aViWWDofDDHN6PB4+9NBDXLFiBS0WC+Pi4uhwOJiQkMAnnngiQvg6dOhAt9tNVVV5zjnn8NChQ7z++utZWFjIdu3asbCwkACYnJxMv9/Pq6++mmS1mIWHOxYvXsz58+eb9SqKwgEDBjAxMdGcB3Xw4MEcP348s7Oz2bFjRyYmJppzkJ577rnmdemGG24gAHO9cDasx+NhmzZt+Mgjj9S55nm9XmqaZj7UL3OY/nppVPjKyspIkhdffDGHDx/OI0eOcMeOHczOzubDDz9sLpeRkcFVq1ad1AZ79+5Np9PJdevW8dChQ5w+fTrXrVvHu+66yzy5rrrqKiqKwmXLlvGTTz7hHXfcwbvvvrvGiRj6kSqu2IgTVLE3PAeimNhv1hqLdNT0AlWNMKpnwbE27VQ10TkIRaGn84XVnzUL40fMCb0Ky+pikxatSZLvvPMOgdBjHFu2bGFycjLnzp3L8vJyrl+/nqNGjaKu61y5ciUBsHnz5nziiSfYrFkz9u/f33z+7+KLL6bdbufkyZO5YMECAjDnCf3ggw949OhR/v73v6eiKOzcuTNjY2P54IMPcvPmzQTAjz76yBwL9Pv9vPbaa6mqKgsKCtinTx86HA6+9dZbPHbsGElyxIgRBMB///vfPHDgAAcNGkQAHDRoEMeNG8cbb7yRGRkZPH78OJ9//nnqus7i4uI617ySkhL+7W9/Y3x8fIPXvC+//NKcw/Tw4cMcPXo0r7jiipO6Pgo/D40K3wsvvECSjIuL4zvvvEOSZsKJpmls2rQpFy1axIyMDK5cuZLDhg0zJ8mt/QBrv379zHCIYRhmJlj4IfIzfvEQE/stWgPv7zuZct2XREeLc6rfeqFq5rnapk0bMyQZ5vHHHzdDi+Fp6LZs2cLCwkJeddVV7Nu3L10uF1VVZWxsLFu3bs1gMBjhHdbMLLVYLHS5XBw7dqyZ+RnRPl3n2WefTZKcOnVqnfKakam5c+dSVVXGx8czJSWFd955JwHQ7XZz9erVLC4u5pw5c8zlrVYrR48ebX6+9dZb2bVrV5JkZWUlVVXl8uXLT3iBDU/91r9//xMuK/x8NCp84Xn9alurVq2o63rELPVhi4mJYVxcHK+44gpmZmZS0zQzPFIzY+yMXxDExMR+pNX+v3dJAAAgAElEQVQfCg2f33XetlFlqqpy+/btJMlRo0ZFjNUnJCRwyZIlBMBu3bpx4cKFTExMjJgE4LLLLmN8fDy7detmvtmjZv07d+5kUVERBw4cSKB6coFnn32WkyZNMjNX/X4/R40axfj4eDNUmZ6ezh07dlBVVXbo0MGczUZRFHbr1s28FvbqFXpNldPpjJiZJy4ujr179+bLL7/MwYMH0+fzMSUlhTNmzIiYwzT8NxwanThxoll3Y49eCD8NjQrf0KFDuXv3bvNdYnfffXdo1omqlOHXX3+dQGiSXqfTybFjx5o/MqvVyg0bNvD9999np06dIlKMw+N2iqIwNze3zg+5TZs25v+5ubm/gBNeTCwK7CQnODcMw4zaWCwW8//09HTzMYS8vDxz+fBYWPhRpE6dOnHGjBns169fnbqtVisLCwv56quvMiWl9oTcoTG8FStW8LzzzjO/i4+P59SpU9muXTvzs81mo8/no8PhYEZGBs8//3zm5eVx6NCh3LBhA3Nzc2kYBgcOHMg//elPzM/P57p161hWVsaXXnqJmhbybj/99FMuXryYKSkpNAyDBw8e5BVXXEG73c6uXbvyyJEjvO2222gYBi+//HIeP36c77//Pn0+H1955RXu2rWLN954IwFw27Zt9V5nP/vsM/7www8kaT56MX/+/NN/tRdMGhW+moLU2DRMNX+0Z/zkFRMTO2MWThb5saYoijmdWVhMa4Y9AbCgoIAJCQl1PEog5FX26NGDiqKwe/fuEWU2m43NmjUzt9NYO8IeWc1tqKpqDtPUt79hj+7OO+9kcXFxHY/2wgsvJACmpqaaXnH4vZQpKSm86aabSJKrV69mTk6Oua7L5eLw4cP5zTffkCQfe+wxpqen0+FwcNCgQWzSpAlTUlJIhoagEhMT6Xa7zSGoMOvWrWOvXr3o8/no9/sj6iRDE4JcdtllTEhIoM/n48CBA7lr167TLja/JBoVvjN9EomJif32zOPxMDU1tV4BA8C2bdvS5/MxOzs7Qqh0XTe9xrBn2atXL3q9XlMkw5mXLpeL9913n7lu+KY8OTmZhmFw5cqV7N+/v1nucDiYmprKmJgYs13hv2Fh8/v9LCws5CuvvEIAzM/PJxCKeAFgRkYGp0+fzkcffdQMcz7//PPmti0WC202G10uF7Oysujz+Th48GACYM+ePSPampwcehmx3W5nbm4uN23aRJfLxeXLl0fkRYT7Z+bMmTx27Bife+45tmnThoqiMC4ujr/73e/49NNPc/ny5Tx48CCnTZtmZueG50v9y1/+wrPOOoubN29mx44dzRuPjh078o033vi5tOhnpVHhC9991Yy5h8OV5557bkTHh+1kPEMxMbHfhoWT1Gp/HwgE6rylQtM0xsbGmusBYHZ2thkqrelVbd++3RxXC4dNZ8yYweuvvz5iguyCggL27duX8fHx5mMPqqoyMTGRs2fPNuvr0qWLub24uDhu27bNFBfDMJiUlMTs7GxqmsaPPvqIQPU7Fy+//HJzcvG8vDxecMEFBMBp06aZIc7w/nzzzTdMTEw029K+fXszbNqsWTM++eST1DSNbrebaWlp9Hq99Hg8HDBgAAHwgw8+YI8ePfjSSy+xbdu2nDZtGhVF4ZAhQzhq1CiSoZlmcnJyqGkaExISqKoqd+zYQTLkFS5atIiBQIAPPfQQ+/Xrx8suu8y8pm/dupVvvPEGXS4Xd+3axfz8fPbp04dXXnklS0tLuXXrVv773/9m06ZNuWLFCvp8vt/keKN4fGJiYr8Jqy3A4Zv0mhYONVosFrZuHZrDt/YbNmrbiYZwwnU29F1DdddMEAy/9SIQCHD69Ons1q0bbTYbPR6PGRYNTwk3YMAALliwIKJeTdOo67rpCbZu3ZrXXnttRBssFgvXrFnDu+66i23atOHgwYNNr9ZisfA///kPjxw5wo4dO9Lv95v9F77xCI9R7tixg8nJyeZNj9fr5QMPPECS/P7771lYWBjhNbdt29ac4q3m2z9iYmI4adKkiLd//FyI8ImJif0q7ETRpMayxWt6mPXNKQqEBC58sa/pfYYz01VVrRN+BUCv12vOJRwWmPAy4b9Op5MbN240vcjaFh6DrK9NTZo0iRDxcMg3vL/9+/dvcGxVVVW2bNmSTZo0qbdc0zTa7fYG+7awsNDcTnjc1WKxMCsri3v37jW939ptBsDly5eb3rCiKIyPjzcTI6dOncoePXpQVVXquh6RGTxlyhSWl5dzx44dLC4ups1mo9VqpcViYZs2bbhx40YuXrzYHHsN32R4vV7zEZawB9wQv6i5OgVBiF7i4+PN/xVFMd9iDwCapkFRFCh1Xm9VTdOmTQEAHo+nTllubi5UVcXOnTtRUlKCdu3aAYC5DV3X0bJlS5SXl5vbC1NZWYnKykr4fD7s2rULuq7jjTfewOLFi6EoCo4dOwaSKCsrQ1JSEjRNi2g7AJSVlaF79+5m28L70blzZwBAeno6DMNAcnIyAMDv95v7e+TIEVRWVpqvvsrLy8OBAwfMOiZMmIA777wTdrsdJLF48WJYLBYYhgGS6Nu3L5588kls2bIFCQkJiIuLw1//+lcAQKtWrRATE4OUlBQoioJFixbBYrGgVatWWLp0Kb766iucd955AIA+ffqguLgYNpsNwWAQjz32GOx2O1q1agW73Y4nn3wSJPHiiy/C5XLB6XTiscceM1/h1aRJE1gsFixZsgSXXnopVq9ejaVLl0LXdYwZMwbdunXD9OnTsXbtWtx3330YNWoUzjrrLPj9fowcORJ2ux3Dhg3DkCFDUFFRgU6dOmHEiBE477zzcOTIEbz//vtYunQpFi9ebM4f2yDi8YmJiUWbhRNSGrLGvMv4+Hj++c9/ptfr/dHbDSfn1PTgao6Tht8wEf4fCIUhO3XqZC4f9j5r152Tk8OHH3643jKLxUKPx8O77rqLhYWFppfUvn17WiwWtm3blkDoGe3wOuFnJouLiwmExljT09OpKIqZQBTeVlZWFnfu3MkLLrjA9Hxrbj8lJYVDhgwx+6Bz585cv349ly1bRgC89957qaoqP//8c7Zo0cLc/ooVK5icnMxgMMiuXbvypptuIhAKv3bp0oVxcXG888472aVLF3q9XvPlyYZhSKhTTExM7HSYoijMzMxssLyhTNX/q51wgn7UP9YIhATUZrNR1/V6xysbSlAKrxtOUurcuXO9odqaQly7HrfbzZycHHbo0CGi38IhzvD4YVhka/Zfeno677zzTvbr149PPPFERLKUYRh0OBymCBuGQbfbHdE+CXUKgiD8CGqHVG220OulSOKLL76os3xKSugVZpWVlae8Hbvd3uBy5eXlZvhUVVVz2fD6Pp8PFRUVEesUFBRA0zSoqopjx46hoqICZWVlZvlFF11k7pOmaXC73Wb94TBrMBiEYRgAgPXr1+PQoUMAgKSkJDOc6fP5UFBQgLS0NACA1WpFly5d0KpVKxw+fBg7d+7E22+/jUAgAACwWCwgicrKSnzxxRfmfgWDQVRWVsLv9wMAnE4nSkpKUFpaiquvvho5OTnw+/2Ii4uDpmnYtGkThg0bhg4dOiA7OxvNmzfH0aNHT9iX4Z0Wj09MTEzsDNvJeHUNWTiEerqtMW8QAC+66KIGs14zMjLMsGVNC7/hwmKx1AnL1txWampqnbfz1HysjgzNdDN69OiIsDAQ8jQbQ6kSuHppbCBZEARBiC7S09Px5ZdfntK6hmGYyUNAyLMMBoMAQt7dkSNH6qyjKAoakihFUWCz2VBRURFRb5hGpA0S6hQEQfgNcDKOSjj0WR8NfV+TSZMmoU+fPvXWeyJqhmsBmKIHAEeOHMGAAQOQnZ0dsU779u3rbZ+iKHjvvffwz3/+Ew6HI6IsEAjA4XA02hbx+ARBEITfHOLxCYIgCL86cnJyfpJ6RfgEQRCEUyKc8QmEMj1r8mMjhpqmRdQHoN6Q5cmEVU+0jIQ6BUEQhN8cEuoUBEEQhCpE+ARBEIRfFLXnOj3dSKhTEARB+M1xyqHO8BQ2giAIgvBTUTup5adGPD5BEAThN4cktwiCIAhCFacsfKqqQtd1JCYm1nm5Ys1lwrOa/1gsFuvJL6xbTmkbp4SqA0qNblNqd2EjXrJ40IIg1EQ98TNpp5df5zWovunUwi8nBkJvfPgxnLFQZ+0JSwVBEAThdHHKoc6fMqX0pxU9BT/pnU1DNwRW50+3TUEQBOG00Kjwhad9adasGYBqD7Cmi/mHP/yhzrQy4eWbN29ufteiRYs6mTth97Q+N1atCl+q3gAUe83s0irR0arrchT0gGL31Fgm9PomxeaGNf0s1BVBJbS+okK1e6DYXNUlttC2NG8Aqt1bp10AYEnKrf5gVIVyDTtQdjSiXRFbVBQkJCQgISk59EU94VlPq97m/41NuRMXF1fnRYs+nw+GYUBVVfh8PgwcONAsy8zMbLAuACcMt6juuHpCugCsoX5TbPX3k7m+02f+H1N88Y/aduRxjaRJkyZo0qRJ9Rd6zb5XAP1HhMtP542S1tB2f51hJuFM8H/4rdR3rp5hThSKPBkn62QzP08mUvl/DnX6fD6Ul5ejpKTkpBrV0HYac0tPO4oKMHji5YRqVB0IVtRfdoL+VB0xCB49cGrbNexAeWm9Rbqu13nrtCAIAvB/zOqsKX4tW7YEAPMV80DoPUo1RU9VVdNbqa3iffr0qTORKQDEx8ejVatW5ivna2wdqsML1PAYIosbaL5mQKnpeak6YKmRZMMgVFftOqv20+45iTum6j7RfCmA1tDdjAK7IzL8abPZYLVaUVBQEPGdzWaDrutwuaq9T6vVCq830ptKTU0N7VKVl1zz+IT7O5xQpKoqFEWpdRwUKFYnbM261tNeteF9qS16Wo0kn/p+YDX6MFh2tJ4KT3RTVRWurjze4BL1id7JTGD7q0eJgn0UhEY4kVPmdJ5g2KnR17MrCidOnNjgK+lxglfe67pOh8NBXdcjvg+vYxhGg+tqmkZoDZdDt9CS1IyAUrdMUajolobXhUIY9vr3S1XZb8gwc//qlNu9VL2BuvWd4H+LxcKEhASOGTOmwf1ds2YNN23aFPG93W6nqqoEQL/fz6ysrAb3a/v27fX3Y4P98CNMUSPr1auPjWZ11D0ONY6dZqnnN2L2r9r4tjSjzrbr+x2GrbHfVJ1jpp7ssmfYVL1u/4qJRZGd6DpW8zoZtsZotNRms7FHjx602+sXCQB88803WVBQQK/XS6fTSV3XGR8fTwDMz89nTk5Og422Wq0N1qvrOg2bs96LniOvO9OmP0mtSoCMQE69dSiKSsMwGBcXRwARHePy+qio9V9QVVU1L6jhfUlMqyE44YutorHOBUlt/ADVbEP4f03TqCgK09PT6XQ6q9qu0GKpFm+73U5FURgbG9tg3R6Pp2HBVtWqC2jdMiM+k2j0RqHh/Wpoew3t8ymbZtCw2uhyuap/Bw5Ho+ucTNtCdVvobHFO3WN5CqZ6EhoV6gjTG/79i4mJ/d+sMRqN6VmtVqxfvx6lpaExlnBCRTh0pigKunTpgr1792Ly5MkgiYqKCnz//ffQdR0bN25EUlISbr31VkycONGsV1VVjB492pwS7cknn8Snn36K1q1bAwiF6rxeL3wxHoBBWJKbwdejen0jPhOH3vkngqWHAQAJw29AwoW3mOW+QTMBAGQQFRUVSEhIgKIoCAaDyMzMRFJSEiZfdikYDCIxMRFr1qwxB19TU1MRDAbN+PCBA6Gxqf17vq7umHBoj5WhvzXCeqqqQlVVBAIBzJw5E7NnzzbDkgMHDowIOwaDQei6DpvNBpLYtWsXjhw5Ypbv27cPF1xwARRFQUVFBUhi//79sNlsaN++PVauXBmRGNSYe9+6sBAdLpkdOn7xGYjtNxWAAigqyCCSLrkXSlUyiJ7YNBTCjQhHVv+/adMmbNiwAX6/HxaLBePGjTNDjAMGDIjY7rnnnou5c+ea+10zlAsANrsDSjjBRVFhy25Xnfij6lXJQwpQWQ5WVphhdVVVccstt0QMmrdt2xbt27cHEBpMt9vtZrvcbjdatGhRf+dUHsfRT96qTrTRrYjtd0XEPmveABRL6Pev2NyhUG+YGolKwUN7YU2rDmPX7jvV7gntV9V2w/vSIKoO2GNqVPXTTt4rCFFBY6rYrFkzappGt9vNOXPmsGPHjgSq7+BVNeRRhe+sa4eZLBYLVVWlqqrMy8vjwIED6ff76fV6abVaOXbsWAJgZmYmLRaLWY/X66WmaYyNjaWm1++lhEwhFJWKYa1xl1191x721sLh1vo8T0VRIjwHRVGYnZ3N888/n4ZhRHhd4XJVVelLSKq3TV6vl5dffjkB8IYbbqDf7zfLXC4XExMT6Xa7zf7TNC1iGy1btjRDwz6fz1y2pum6bu6P1+tlWloaATAuLq5RL+eEHpCqU3P7a3zWTK9EtYU8rdjYWHq9XsbGxppts9vt1DSNZ511lrkvNUPgSUlJdLvd9W4/KSmJhmEwMSmZmfmtmNO+R0R5YlIyu3XrFrEPTqcz4rfmcrmo67pZv6ZptNlstNvtTExMpNVqZffu3Rvf9/DvR1GpWOuJNFidkZ/DoXJVo9pYSD5iG6czXFlPXZbGPWAxsWiyUw51xsXF0Waz8ZVXXqleAeC2bdvYqVMn3n777ezevbt50SkoKODIkSM5YcIEDhkyhKNHj6bVaqWiKHS73Rw5ciSzsrK4ZcsWAmBBQQGB0MUsMTGRt956KwFwxowZHDx4MLt06RISWUVhTJv+1Fxx1GOSaM1oRVtuJ8IIXVwVmysUCotLY0zbc7nolc1888036fV6CYQEZPjw4dyzZw//8Y9/0Gq1RoQMDcMww66KotBms7Fz587MzMzkwoULCYD79u1jYmIiW7RowfT0dC5YsICFhYUcN24chw0bRgBMTk7m7bffbm7X7XbT4/Fw1qxZbN68OVesWMGEhAR++OGHtNlsTE1N5UUXXcSDBw8yLy+PLpeLO3fuJAAGAgHu3LmTmqbxs88+M/s+bA6Hg06nk9OnT2e/fv1oGAY7depkhqU7duxoinSPHj2Yk5PD5ORkc31v97HmhTIw5na62w8N3UAAVAwrky97kBnXPEd7bkdqrjg+9OpW85jVpEmTJjQMwwwPh0O0/fr148CBAyMEKdzXHTt2NNdpKAwaviHp3bt3nbJAIMBLLrnEXK52+VtvvUWSnD9/vimQNcPE2dnZBEBVq3FTpShUbW56OgyjNTWfemyq+fsKWe3tVH8O36hYrVYmJSXVGRpQdYOqpnPsVbfxlrm3n8RJ24hAnqzIiolFgYWv1/WVnbLwzZkzh+np6QwGg/zggw9YWlrKI0eO8Pbbb2dmZiaPHTtGkrzkkktoGAY3btzIIUOGmHf3Pp/PFJXExET+97//pa7rpqcQHttyuVxs1aoVJ02aRCDkqS1YsIAffPABrVYrzz//fL6zbTctDjdtKfl0ZLVm+tX/ZmDUbaGdtzqYOvYv1K12Ln/pNZLkV199ZXp8f/7zn1leXs5vv/2WCQkJzMjI4N///ncmJydz06ZN3L17t3mRvPXWW7lnzx4uWbKEiqLw9ttvZ0VFBZ9//nlznE1RFMbFxXHp0qU8fvw4N27cSABs27YtSTInJ4cdOnSg3W7nP/7xD+7du5dOp5Nut5tvvvmmWbfL5eL27dtZUlLCgoICKopCTdNotVp54YUX8tZbb2W3bt3M47Fq1SpmZGTQarVy5syZ7NatG2NiYuhyufjggw/y4MGDDAQC9Pv9bNWqFa+88kqmpKTQZrNx6tSpPHDggJkckzJmrjmulzbtH0y/+j/MuOY5qm4/Vbub6Vf9i/6h1xKKyivveoQk6fF42LJlS5aVlbG0tJRz5syhpmns0aMHi4qKOGfOHHbp0oXffvstKysrOXToUPPHCYC9evViVlYWk5JC3rLL5eK3337Lzz//nLGxsczNzeX8+fOZkZFBRVHo9/t55MgRnn322QRAp9PJ5ORkOp1OTp06lcnJyUxJSeGiRYuo6zqbNm3KQCAQ8Ru+4YYbaBgGFyxYwMGDB9PtdpsRiLPanm16YardQwBMmngfLcnNQgJj2GnJaMWUyY/Q2bJX9UlVyxvs2rUrmzRpQrvdznbt2pnCF/47duxYU8hrCnXr1q2p6zpHjBjR8Mld1a7QdjUqFnuNscGGk7TExKLdTln4unTpwtmzZ5MkZ86cyZiYGDocDubn53PDhg0MBoN8++23mZiYyGHDhjEnJ4dOp5NpaWm84YYbuHv3bnbq1Ilz587lxIkTGQgE6HQ62bx5cwLg1KlTmZSUxOLiYjocDqqqSpvNxvbt23PTpk1MSEig2+3mWWedVWenzp+1kGedO55AKHHD6XRSVVXqus6ioiLm5eXx7LPPZqtWrVhUVESv10vDMJicnMyHHnrI9LzC7Nu3j7quc8KECayoqOBTTz1lhnntdjtTU1OZkJBAVVX56aef8oUXXqDVaqXL5aLH46Hf7+fYsWO5evVq2u1204N0Op3mHYnFYqHP5+PIkSPZu3dvFhcXMzY21qxn/fr1XLlyJa1WK71eL3Nycjh9+nS+9957LC8v5x133GGGlm02Gy0WC5OSkrhw4UIeOXKErVu3psPh4N///ndOmjTJTARp1qwZ09PTGQgEzESf2pZ82d+ZcOHNhKqGwn26lYbNyT6DhprHWVVV+v1+OhwOMww7YsQILlq0iEVFRSwtLeXkyZPN8CIATpw4kV999RWBkGfkcrlot9up6zqzsrJYUlLCN954gzabzRQFj8djlrtcLrrdbhqGwUAgYIaHk5KSuHbtWiYnJ7NXr2pRMgyDNpuNDoeDF110EX0+H51OJ30+n3mzEQ6lA6CqadTc8TT86Q2cQKFwOlStRjhUocUWEpz6EmzcbjctFgtjYmKYnp5u3oCFb5rCfRD+rmYIPj0rm0Z8hvlZMWyn5uUpDScziYlFg52y8Gmaxm3btkV8V1lZyb59+5oXlKZNm/LWW29lMBist46ioiIuWrSozvepqam85pprmJKSQpJ8+umnWVhYyF27drF79+6mV/XAAw+Y66xfv94Mj4UvGKqqMhAIcMeOHfz888/Zp08f02vq27cvP/30U5Lkq6++SgARY1BOp5OvvfaaWf9rr73GgoICOp1Otm3blh06dOCCBQtIklOmTGGXLl3YtWtXc/lWrVrxqaeeIknu2rWLffv2NS/uNdtdXFxMTdPodDrpdDrpcDhos9n44osv8rvvvmNycjItFgvdbjcLCgr44IMPmnU//PDDpuAqikJd1/nyyy+bdY8cOZI+n88U6bvuuiuin5988km2aNGCLpeLKSkpHDFiBFNSUlhZWclgMEiny0VXTCwNm4PepExmtytmux7ncu/hY4yJiTEv1mHv3Ofzce7cuVyyZAmB0IU/PJbrdDq5c+dOkmR+fj4BmPsLhMYgp0yZQpJcvHgxvV4vHQ4H09LS+Ic//IGKovDRRx81j0V+fj4VRWGLFi3YokULTp8+nSkpKfz88885cOBAxsbGUlEUFhYWMicnh7fccgs3bdrEli1bmmPG4ZB8+EZnxowZTEhIoMPhYFZWFq+//nrGBZKZOvoW2rLa0NfrMtqyWtNIyCIUjUmXPsD0q//NhAtuouqIoeFL5oz5D5MMhZ4zMjKoqiq//PJL8/fodDp59tlns0WLFgTAAQMGsHfv3rzhhhvo9XpZXFxMVVXZpEkTjhkzhitWrKgzlhwyeYRBTOxUrTEaL/0JmT17Ntu1a8c9e/Zw//797Nq1K2fNmsVdu3YxOzub8+bNq7NOeXk5d+/ebdozzzzDpKQk7t69mxUVFTx48CDbt29vXlxrs3r1asbGxnLt2rV1yn744Qe++OKLLC0tZXl5OZctW0aHw8GtW7eSJJcsWcKmTZty+/btDAaDfPnll2m327llyxazjqNHj9Lr9XL16tV16n/vvfd4/PhxHjx4kH/84x/ZuXNns6x23S+++CKtVisHDBhAr9fLkSNHcuXKlXzuueeYnp7O0tJSlpWVkSSPHz/OgQMHcsiQISwvL6+z3X379vGzzz5jMBjk5s2b2aJFCy5cuNAsv/rqq9m9e3fu37+fW7ZsYWJiIl944QWS5N69eyP6OzU1lcuXL+fhw4dJkhUVFSwtLeX999/Pbt26sbS0lMePHydJfvbZZ3Q6nVy9ejWDwSATExOZkJDABx98kGQojJ6fn89gMMi33nqLVquVHTt2NNv1wQcfcP369eaNhKqq9Pl85o3O1q1bWVpayqSkJObk5HDGjBnmzdeyZcsYCAT48ccf84UXXqDf7+fbb79t1h32CGs+Yzry4kuZdlYn+jpfQGtSk9DJo6i0ZbRi5mUPMHfWSsalN2X7zt2Yk5Njer5A6LGdtWvXRjxOEh5ftdlsLC8vZ3p6OufNm9foc69iYmKnzxrjjAnf8ePHOWnSJHq9XgYCAV5xxRXmuBEA0zsKW32sWbPG9BhJRnghNdcNeyG1PS+n08l+/fqRJL/77ju2a9fODIV16NAhwrMKBoOcPXs209LS6HK5mJeXZ3onYR5//HFzTLQ2I0eOpMfjocfj4QUXXMA9e/bUqTvs+RmGwfT0dN5zzz3ct28f16xZU+egFhUVkaz2ZO12e8R+hT3ZTz75hLm5ubTb7UxPT+f8+fMj2nXs2DFOmDCBbrebCQkJdcprkpGRwVWrVpmfFy9eXKdd48ePN8treptut5uJiYncvXs39+/fb4YxbTYbNU1j586deejQIXPdmTNn0uv10m6385xzzuFbb70VcaOTnl43NLljxw6SZGZmJnVdN0XGZrPxsssuizgWbrebDoeDQ4YMod1u56xZs+hwOLjq1Td41X1PEYpCV1wSzz7/UiZn5fLpfz1Hu91uhi3DpigKu3Tpwscee4xAKJEqEAiYmbcLFy40b3RmzZpVp9a1PSAAACAASURBVM2KovCuu+4i0PhzrWJiYj/OGuOMCZ8Q4tixY1y+fDn79u3L2NhYTp48me++++6ZbpbJRRddZD6C0bRpUzNsvW7dOvbq1Ys+n49+v5/Dhw/nN998Y673yiuvsLi4mB6PhxkZGXVudEaOHMnOnTubF3uLxWKKtt1uZ9u2bRkTE8OYmBj27NmTmzdvNm905s2bxxYtWpjrGoZR50bnr3/9qyl84cSS8I3OY489xpSUlIiwec0bnSeeeILNmjWjrutm1mleXh6XLFlCq9Vq3mQkJiZS13X6fD4+++yzBEKJWbUnGQiPaTY2EYSYmNjptcYQ4TtDbNq0idOnT2d8fDyLi4u5dOlSHj169Gdvx44dO9i/f3/GxMQwEAhwypQpLC8vZ1FRUcSzlVarlc8++ywDgQBXrVrFVq1amaJgt9s5YcIE9u3blyS5c+fOiMdDwnWEx7xqWljwwuJU8/k8wzDMTMia2ZCqqtJqtdJqtZqeX32PNTgcDrZv377BaczCwnXSM7zUsJiYmDpT8Z2snZaZbMTExBq1xvjlvb/iN8zhw4exaNEidOzYEX369IHdbsdbb72FNWvWYMyYMXVeNfRzMHnyZCQkJGD37t14//33sXbtWtx3330gCZfLhfnz5+PYsWOYN28epkyZAkVRMHXqVOTn5+O+++7Dfffdh5iYmP/f3p2HSVHdewP/naqu7urqdbqnp3tmevaVGZZhh2EH2XTAAQzrEFA2NciiILgENVeivkokxCjLNRgREEFDIvEGjBHU4EZAX0nwvXJVdAwERATCHRCG7/tHTx26ZgNBQ7R/n+c5zzPT1VV1aju/Oqeqz6Hp06fTn//8ZyIiyszMpPHjx1OPHj2opKSE0tLSSFEUmjdvHhHFxmIUQpCu67Rlyxb66KOPqLy8nMLhMF1//fX0s5/9jAoKCsjtdtPGjRvJ6/WSEIJGjx5NhmGQoii0YMECMgyDpkyZQoqiUFlZGeXk5MjeWW6//XbauHEjHT9+nG644QYaNWoU9ezZkxwOB2maRi6Xi44dOyZ7xBFCUFJSrONyIQQlJydTnz59iIjI6/XS5MmTyeE4N9zQl19+KTvJNgyDevXqZdmvEydOtPwfP6TK2bM8Mghjl1VzUTH+N2QnT57EtGnTkJKSgqSkJFRUVKC6ulpOr/9MTlEUTJ8+HcD5m8UGDRpkmVfTtAY/lAbOPc+644475GcrV66Ub9KZ6eWXX5bT77zzTrRs2RKqquKuu+6yLO/s2bO49957kZGRAY/Hg1GjRuHo0aNyenV1NYYOHYqkpCSkp6fjsccek9MOHTqE8vJy2ZNJly5d8NprrzXI89mzZ9GuXTsQxV7Tr6ysxKZNm3D77bc3ma+FCxdatsd81f/QoUPyWJjP5cLhcIPncitWrJA/LRk4cCA+++wzOa1+E2RxcTGWL18Oh8OBcePGYc6cOZg6dSqysmKv1DscDtjtdvnKfUpKiqWGZH5eUlKC1q1bo0+fPvINUKLYj/rNNxnvu+++BndlPXr0wI4dO+Rv+4LBoPy9ZPz3MjMzLTWl+JdIzH1bf9mcOHFK3NScZqfu2LFD/v3AAw+guLgYffv2hd/vh67ryM3NxenTp/HKK680CHxEhJ/85CcAYm8Opqamyt+75eXloV+/fnLZjc3bqVMnANagaXZjNmPGDDnv8uXLEQ6HmwzITzzxBObNmwe32w1N05Cbmytf/Fi4cCEcDge8Xi/8fj+Sk5MxdOhQOa/P57MUwEII+cbmJ598YtnJZvdtEydObLSbMaLYD52bmkZEeOihh3Dq1CkUFRXB5/PJZ1SBQACKosAwjCY7/M7Ozsbf//73Bm8NtmrVCqmpqXK/NpbMNxCb7OC6XlPjhSRuzuPEidPlTBcd+OJdf/31yMnJwYQJE1BTU4NVq1bBbrfL37nFmzdvHoQQ8rX3Tz75RNZWjh8/LrvYasxf//pXEBGefvppAMALL7yAZ555BnfddRdmzZqF/Px85Obmyu//4Ac/gGEYOHDgAGpqalBVVYVhw4bJ6Vu2bEFmZiYGDhyIBQsWoLq6WgbGIUOGYP78+Th79izOnDmDWbNmQQiBEydO4Pjx4yCKvazw6aeforq6Gn6/Xwbk7t27g4iwc+dOnDx5Ur6ZN2zYMOTm5sLpdKK8vNzSF2hVVRWOHj2KEydOyGdiV1xxhfxR+kcffYR7770XZWVlIIr17EEUqwV5PB7893//N+677z44HA7ouo7FixfLQFpYWIiZM2daAlR6errspmzkyJFo37498vPzYbPZ4Pf7ZRCt/xuy+KDl9XoxYMCABoGvV69eICJ07twZRNY3Ej0ej+xSzHwOJoSApmkoKiqyBGezezfzO2PGjGmQp2g0CiJC165dLZ83/tu3C0tmjfbbShfz3JATJ07fXLrowEdE2LBhAwCgffv2coHmD6nD4TCmTp2Kv/zlL5bOmIkI+fn52Ldvn3xLr36mdF1v9DV9M61fv16+URj/ogQRyaC5bt26Ruc1f/6wbNkyywsIHo/HUovNz8+3FJ5mZ88bNmxA377WzpJtNhsikQgMw8DAgQObLNjKysrQrl27Rrd52rRpePjhh5GTk2OpuQkh0KZNG7z66qvN1q42bNhgmSd+Wnzn343Nu2TJEkuQiU/nG97nUsf0+8bGBOTEiROnC0yXFPhatWolO5q+kJVlZ2c3Oa2pt+BUVcWqVatkTaexFN/BcmNp+PDh39oO9Hq9SElJ+caX21zzIxGhvLy8yWmhUAht2rS57CfXvzL5/f7LngdOnDh9N9JFBz5d1zFhwgTk5eXJbqviawcul0vW9DIyMuTwNGaQdLvdiEajDfqHNJ8pzZ8/H8nJySgvL5f9QJrfycvLw86dO+X6VFW1vMBgdg/l9XpRUVFhWX5WVhZKS0sbBKv4Zrfk5GQkJSUhOzsbhmHA4XBYhlu66aab5HxmZ9v1d6zdbofb7bbke9iwYcjOzpaFtDkKgZlnwzCQnp4u81F/v5idKNdflxACeXnWAXfjB2WN/943fQJdzDL/XfLBiROnxEzNEXU1u0ZpmiZf2a7PZrM1OU3XdTp58mRTi22SoijyVe/4v79NbrebTp48SW63Ww46W59hGPS///u/DT5XFIXqbh4snze3b8z5Gts2IUSDZTHGGPv6mitLmw18QgiKRqN05MgRy8jg8c5XyDdHURRyu9107NixBtPy8/PpwIEDcsTti/FtBZJLDcoc4Bhj7NvVXBnb7A/YhRDUtm1bSktLs3wWLz7o2Wy2r5WxyspKUlW10WmqqtKNN95o+SwYDDbIX3OaWjbR189rvPMFPV3Xm50e/2Pmr+Ni5/u+Ot9+Zoyxxpy3xpednU3V1dUXVKv7PtVkLra59lL9q5p4GWPs++yia3xERIcPH77ggrj+iuJrivUZhiG7iGqMEIKysrIoEAg0Ot1ueC4oT41p2bIlKUrzm36xQc/j8ZDD4ZC1zcbW079//ybnb25fh8Phi8rTd8n5avHfBec7ty6Fy+X61pbNvsMc7gv+qvga3/3aRNPnfk5OzkUvVlEU6ty580XPX995a3wul4tqa2ubDATt2rWjnTt3fjOZiasxZmVl0cGDB6mmpuZrL0fTNDp9+vRFT78UHo+Hjh8/ftHzq6pKtbW132COGGMsjqYTnf7Xt2b9q11Sje/EiROWoFf/bvbrBL3zdcIc/0xu3759XzvombWF+kGtfs2y/vTm8mVub1PPBOs/dzODnqIolJqaegG5tooPeuer/YwfP77Z6c3l2W63f+28fduaqt1fqMv1DPR8z4s1TWvyHPs2a4fn832oXbOLEB/0bI6mv3cBhNbM/OrlK2Oae7+D6AICn6IoFIlEiIho0qRJdPbsWSooKCCiWHNlPIfD0eBiEkLIi1vXdZo5c6YlU0IIEkI0eDvUn5xiWU7gypnkbndV7G7FzJv73MsutqRUglBJ1CtIFEWhf/7zn5Z8jR8/niZOnEiqqlJxcbElwA4ZMkT+XVxcLJselyxZ0mDfOJ1O6ty5s2WejIwMKigoIAD0+eefy22MV1BQIHv6r3+A4r8bCoWanN6pUydat26dZZr5sofdbm/yxQ+3200Oh4O++uorCoVCcpkez7mmYyEErV+/3lKgm/kQQpBhGHLepni9Xsv/8c2/jUlPT6cjR46QzWajaDQqP/f5fOTxeOR2Z2dn0+TJk+V2mnkSQtDp06fJ6/Va1hMf4BVFkeeiOcpD/PT6TcnxQam5ANWxY0ciOvfylRDC0sx/7bXXNmjezsvLI6JY0CwtLZUjQZjqHz9zm3Jzc+W0li1bNpqf+O0QQjS4ITC3BQCFQiESQlzYjZCwEan1bi4sBaeoSxdCiS1LPXeOKS6/taks7m/VF7H8H5nwcHMZtf7rCpKwG41/lYiEphPZDfkd4fRZv6DaYuVOvWY8e2abhsttJJAIu0GkNHHu131f8dU79/ypRKRY1qmlFlvnrcunFs6rv0YirflKhuLyk2L4SNQtXxj+2OdJ6c3MVW+/CpX0nPakeJooC3Qv2ZKziMS5skPXdbLZbOTz+cjhcNDYsWPl15OTky2zu93WJtn4m0dVVS3XpN/vl39rmnbeVrPzNnV+26644graunUr1dbWfv0XY4RChIt/EeRSmhW/rebSS8nT9+nlIta08x3nS/mJ0eUkHC7CqcZ/NhUrdJs7txUi4pfC2DmX1NRJRNShQwdKS0trEAgVRaEHHnigQWSOn56SktJkE5TT6aQXX3yR+vXr10yQbTqL/l4/bHyCUCgpKYm6detGuq43WHZ5eTn17t2bkpKSLDUdyyKaCfqdOnVq8kWTrKws0nWdfD5fo9OJrDUDIqIWLVrIabt27Wq2NuV0Opvdn+FwmFwul+VuKDk5mcrKyppc5owZM4iIaPDgwY3WbIQQVFlZKWsp9Xm9XkstLZ5Zk2juwXZz+zorK4u6devW5PTs7OxGa5Lmb0S9Xm+Ttd8ZM2ZQdnZ2k8s2j0t8q4Vp0KBB1KVLF5o5c2aj86qqSikpKY1O8/v9tG3btibX2759e1qxYoVlnfH7qFu3bs3us+ZunMzzvbFr1tzOsWPHNrrPAsG6FgJbw9qhMFtiRNO1euFoutZFRIRTDTuJuGDKJdyk16/FxnO4mt2mWI2siXULlZosv8x1ao2cm4pKvl4TyREtbXq1mk5aeknT0+1OS23aunwbCae38Wkkmn1Bhaj5l2Mc2WVEzZybuq432/ITX+urf8116tSJOnfu3Oi5b7PZLI+Wzltpa7Y/M4p1YLx161acPXsWADB+/HgQxXrjj0ajKCkpQWVlJQYMGCA7fDY7e87KyoLb7ZZdh7Vt2xY9evSQPeO3atUKX3zxBVwuFzZt2gQhBFxmN1yOWD+WtuTYd90dhoJIwCjpJbukSZu2HMLpA5GALZgBV8dK2IKxnvxVVcWVV16JIUOGwOVyoUWLFhg9ejRUVZXdk9ntdvTs2RNOpxNFRUUIBAJwu90QQqCkpAShUAh+vx/du3eHzWaDoigoKSmB3++H0+mE0+nE4sWL8Yc//AFTpkwBUaxbLb/fj61bt2Ly5MkYNWoUdF2X3YuFQiHs378fbrcby5cvBxFh1apVct6amhosWrQIgUAAQgh07doV7du3l911mUM6md2v/epXv5L7Q1EUVFRUYNy4cVBVFT6fD+FwGP3790cwGERGRga6du2KiooKKIoiu5dLTU2FEAJr1qzBiBEj0KZNG/Tv318eJ1VVUV1djdraWnTp0kUeT3M+olhXbcXFxdB1HZFIBB9++KGlA/C33noLRISKigps374dhmHIrtluu+02/Pa3v0U0GsUnn3yCoqIieY7t2bMHRLHRJ4YPH46srCx06NBBLtdc/6RJkyzdzgkhUFhYiIkTJ6J///4oLCwEUazfVfMYe71efPDBByCKdT/ndDrlSBlEJDsaf/LJJ/Hyyy/LsQiFEIhGo9i8eTMeffRRZGVlWbqtM7ue2717N3r37i3XZ3Z7V1JSAgAIh8MYPnw40tLSLF3irVq1CqmpqUhKSgJRrNs7t9sNl8sFv98Ph8OBkpIS/PKXv8SKFSsa9IEbDoexdu1aeL1eGIZh6drO3Lcej0eOhGEmj8eD3NxczJkzR3YzaO4nl8slOxtPu+FXIPu5ETaEwwXVFwbV7TfF8ENodZ20K3V5EwoUpxfOwq4gxQajuAecJX1gT28hl0E2OwKDpkPo1j5sncU9QE4P3G2vhBbOiy3TVrd+VQM5znWjqHrD0Ausfdz6+lwHobtBVDeGoysAxWt2ZyhAQoG//zQohh+utleCnH6Zb3e7ISCbA7akdLjLrkTyD+6GLZwvl+1qeyUC/a+P5aNuO+W6FQ2qJwThMODM72yZpnpi54stkI7g0LkIj70PQottk9A9IE1HuOr/IDzmp3C1GdBg2UlXTEN4/IMgElBcAZD93D4Quge+nj+EPa0IpOnw94mNlKLVXY/d+/aHN5wBezgX3rKB5/JOBHukQO6nVRtfRF6r2LWm57aHcHqhelNAQkDP73RunmhpbJt8Eeg5sbFH9ewy6Dnt4OtRJfdl+w4dcfPNN6OoqAivvvqq7BayX79+ICIUFBTg1KlTmD59uhxqLv44Hjx4ECNGjEC3bt1AFBsIwZwWDAZx+PBhpKenw+l0Njo2qiW2nS/wmemDDz4AAJSWlp47eKqKuXPn4qOPPkLbtm1l4WImr9eLvLw8uN1uOWBrfOFw3XXXYdu2bfD5fI0PMWN3whbMbPi5mWx2CMe5E1omoSCUlonWrVvLAim+/0tFUeB2uzFu3LhGl1tYWCin1R/wlCh2M+D3++HxeOQgsfIi8/nQr18/PP3007IQNfsVzcnJQXp6utyPTQ2rc/PNNzf6eTAYxMSJE1FaWmo56GaaO3cuJkyY0OhoCOZYgU1tMxFhypQpaNGiBVJTU9GpU6cG0x999FG43W5Lf62apsHr9aJVq1ZITk5udN2KouDMmTMYPnw4ysrKLMciEongzJkzuOeeezBgwAA53FP9VFlZiWAwiNLSUrkOIQS6dOmCoUOHNjqP0+nEM888I4dOqp+EEJg9ezai0Sh++MMfWoKPEAK5ubnQNA09evRoMGrGU089BQAoKSlp0Leq2a/qm2++iXA4LI+/ec306dMHX3zxBYjO9bdqGIbs19UMOo116i6EgNPphNfrRc+ePZs8lgcOHGhwPRIRnnvuuQbns3mtOp1OtGjRosnROswO6DXdOl1oDhglvSFssfM5NPxO2NOKLdels6BLbDtb9Gi4bMWGpAE3Qtjs8PUY33B6XcGshfMbXOuKKwCjqBuEWXgrtlgAVhrvED8+qcEoSI19zyywG6xX1WJBvbFlCBW2pDRkzd+E9B89AcWVFDevHb5eE2ALRhsE8vhkS0qzBsu6ZI+WwNOxEkl9J8kbiliq+1tRkDLmp01vn6LCkd220Wn5+fmYNm1aE6OmCLm+xs4/LRzrL9jb5ZrGrynNCVLt544Fkdy+dr0Gw+v1WvovJiJcddVVICIUFxcDiA20XVxcbFmuz+cDAFRUVFhGoDHzOGrUKHTq1AmBQEBOu+jAp6oqfve734GIcPjwYQBAy5Yt4XA4UFBQgF69egEATp06ha5du1oyWVxcjJMnT8qRs+12O2bPno3y8nJkZ2fD5/NhwoQJWL16NYhiPe8fO3YMfSffEbtASnpB9YZglPaN7Tibo0GQU5xeGC37QdgcIFWD0OKG5KnbsbquIzk5WdbUzItcURRkZ2dbDq7NZkNmZiZ0XZd3G6qqIiUlBYqiICUlBTabDUIIuN3uRk8MMyCag8ampKTIA5WdnY2SkhKUlJQgEonIgtbsfDsSiaCkpARJSUlQFAXhcBiBQAA2mw2qqkLXdaSmpsLn8zU6GrmiKEhKSmpyaCIhBAKBgKXWShQLqEIIFBUVwW63y/H+iGI1IZvNhhYtWkDXdaSlpclag8vlgqZp0DRN7peMjAzk5+fLbTMHLW7RooWswcjjV7eN8cfGzJM5MG5hYSGcTifsdjuEELKDb6JYsPB4PA1G7lBVFZmZmQgEAkhKSkIkEkFycjJsNpscv9DtdsPhcCAjIwPJycmWMQLN7Xc6nXK7QqGQZd0lJSWIRqOw2+2w2+1ITk6WtWhzOx0OR6MDDwsh5DHKzc1Fbm4u/H6/bFWI3z5d12XeNE1DRkaG/I55bpjnY/y5ZI5oXz8oq6qKYDBoqRnbbDY4nU54PB5omob8/Hw5BqJ5DgSDQXluq6oKodhitTTVjpTR9yJz3vMQdidIO7cfzUKSFBXhqgdj12N2GYTDBT2vkyzgFd2N9JuegiOz1bm81l3zRITIdb+I5d0Xse5LVYOw2WMBV7VBz4obrcTmgOpNiZUJmhPBobfCkdESiuGD4kqClpINV2kfaKFsEAmogXQk9b8ewaFz6wpwHZ4OV9eVObEaT+rkR5E08EYQxfadq2wQbKFspE56BJnznodiBkjFhpTRCxGduSa2Daq1g3s9px1CI++B6g7C03Uk7GnFSL3uEeg57eU2G6W94elwNSJj74PDnwJSVBAJeDqPgLA7Y7Wp3tfC33fSuTJRxAJZ+o+eqMujgNAcsVp0XR6EELDb7TAM44I6fZcd9xs+CE2PBVtFhRrMBNnsICEgnLFzTtid0FJyobgDCA65BYrLj5TRP4XQdDgySjHpl38AEeH3v/89Fi5cKMtP89o2h7rbt28f3n//fZSWlsobYXN4vD/+8Y8yuNntdkycOBFCCKxYsQJEhL/85S/yRviiA1/v3r1RVlaGtm3bAgCqq6tlM8748ePRo0cP1NTUYN68eTIj8Rf34MGDkZmZCafTieTkZBQVFclag6ZpmD59uhxjzhxx3AjEAo4tlA1HeguEht0O1RuClpIDYXfGLq66gxgZ/xAybnkW/r6ToPpSYk0FQgGpGtLLeiAajcrCMb65saysDFdeeSVcLpcc7LV+8Ko/VqBZwCmKglAohAcffNBSGzQLnEAggKqqKllIxu8Tp9OJ3bt3Y/fu3XjvvfcwYsQISwCYN28eNmzYgLy8PKxduxa5ublyVAq73Y5IJIKdO3fitddewxVXXGEphAOBABYtWoRFixahQ4cOGDJkCPr3749oNIrU1FS0atUKw4cPx6hRo7B9+3Y4HA643W6kpaUhLy8PkydPxoYNG5CdnY1QKCQL2qSkJKxduxa33XYbKisr5cC/RITMzExce+21SEpKQl5eHiorK/HSSy9h5MiRKCgokPty2bJl2Lhxo+VCMwP4I488gt27d2PcuHEIhUJQFAVVVVUIh8NIS0vDokWLsHr1ajgcDtjtdll7UlUVoVAIM2fOtBTu5v622WxISUnB3Xffjblz58qavzn6RXl5ObxeL1599VXs2rVLNuu63W706dMHTqcTo0ePtgSA+PTWW28hMzMTV1xxhWxiVRQFqampGDx4MNxut3wEYAauaDSKkSNHon///ti0aZO86bDb7fD7/UhJSYHb7UZOTg6ICCtXrsRPfvITqKqKwsJCeL1eDBw4EBUVFdB1XQZYp9OJsrIy2O12ed5FIhHZlB0/Ysrq1auxY8cOPP7445Ybt8GDB6NXr1646qqrsH37dhQUFMh5SktL8dxzzyEQCGDAgAEy+MUHIHtaMUjVYLToZa35EMGeVoTUiT8HESE89j4kD7utrrAWEA4XwuPuR2DQdNj8kVjzXL197Q5nQuhuCLsTqVOXweaPQPVHIHQXjOIecJX0AgkVqi8CLZQVCxJKLH/ussEQmgNZs57GDQ+vQ1I0T9ZoDK8frTt2RSCzCMLhgrAbsKcWQPGGY8E5s3WsrBEKIgWtIDQHhKbLmq0tmAFvl2tiwdOs3Wg6FE8yMuc9j6z5m6DoDUdQISIoqg1FFVORMetp6FmtG35HUdB35s/wHz9fLo+zUBQ4M1siMOgmKLoHvl4ToOgeuNsMhCO9BUTdfvd2HwsSCuzREkTH/RSRrHOtQ+Xl5XjzzTcRiURw0003YefOnaisrITP55Png6qqcLvdSE9Ptwyd5us5AUl9J0P1hkCaI3bjE1db9fX8IYTNAZsvUtf0HQu+sRq4CncoHW3btsXu3bvRsmVLeV24XC7cfPPN6NSpE/bv348tW7bA4XBYHtfED3j+85//XJa7CxYsgMfjwZQpU5CWloaxY8eisrISEydOvPjA53Q6UVBQgI8//hhAbCT1xu4SotEoFi9ejMcffxyhUEg2hxYVFWHnzp1o3749VFXFsWPHsGbNGnlRPvbYY9i5cyeIYgOpWmoqQkFoxJ1Im7oMpGrImP0MsuZvQvLVt8q28LRpy5E1f5Mlqd4QSCgo7n4l2rVrB5vNBrfbbSkck5OTsXXrVvj9fgDAnDlz4Pf7ZS3l7bffBgCEQiG5410uFwzDQGpqKt599108+OCDqKysxOjRoxEIBGSt5+qrr8bMmTPh8XiQlJQkm8jsdjuGDh1q2b/m8yXDMDB+/HjMmDEDDz/8MAzDQDgcbtDktHHjRjnv6dOnQURytPmsrCy8+OKLct3hcNjSzBYIBLBs2TKUl5dj/fr1sgZJFGviPHPmDB5++OFGa7Fm7djv9yMYDFq+k56ejrfffhtVVVW49tprMWHCBGiaJpe9bNkyAMCaNWvkReRwOGRt0Waz4amnnsKCBQtkrbr++pctWwaHw9FgXEiPx4N169ZB13UEg0H4fD5LgdyrVy/U1tbKffbKK6/I2mooFMIrr7wCAPj444/lHafH40Hr1q2xdu1abN68Genp6Th79ixqamrg8/lgGAZ69eqFXbt2yTvUUCjUYMT4nj17yv1lLtvr9aJjx44YN24cACA1NRU33ngjsrOz5U1VRkYG9uzZA7vdjm3btuG1116DzWaDYRiw2+2oqqrCF198gdatW8Pj8eDWW29FaWkpHA4HNE3DrbfeikgkgmeffRZlZWWYN28ep7TtxAAADrNJREFUfvzjH2PUqFEgOvfIAgB+9KMfyRppIBDANddcg3/84x9yek5OjhySKycnB0uXLkWbNm0QDAYRDocttVmbPwyy2ZF67RJ5LRqFsWdt3i7XIOOWDSDVhvDY++HpeHVd4a6ChBK7nhUVng5Xy3mTB94IUXczUVFRAYfHD1JtUFx+KC6/rBkJhwveziNAQsDVsh8y5zwHd7urZHBSfWGkjLwH01a9Lbdr0qRJsoCvqqrCtGnT4PZ4YHh8EMq588fl9eM/7nsAmqZh/5F/wttpGBTDLwOnr3w0MuduRHDwDKieINztroLqDsBXPkpuh7/PdXAWdEHa1GWwBdJkWVBRUQEA+Pz4SSzdthdpRW1lE7Lm0LF85ZMyvytWrICmaUhJSYFuuKD5I0jqe51ctrnNJBSQUKC6gzBa9ISR3QarXv8I9957L7KysqCqKt555x0cOnQIRIQvv/wSQGz4OfOxjKZpWLhwIU6cOCHX73DV1eg0HY6MlkiuvA2kqFBcfgjDi3M1TgFvl5EgVUPajSuhuIMQDiNWK7Q7Udh1gIwl8eVf27ZtsXLlSnTr1g0nT57EgAEDMGbMGJw4cQI+nw+DBw/GjBkzGpR9V199taz9de7cGW+++SZKS0vluxPNaXaqYRiWwnbhwoWIRCIYP3685Xt33303CgsLkZycjN27d+PJJ5+EYRg4cuQIAODxxx+Hw+HApEmTcPjwYZSXl0PTNBw8eBBnz55F586dUVVVhY8//hiT7loSuxMeeisy5/4GKT+4G1o4D95Ow5B67ZLYQ2FVQ3TGaqTf8Ct4u41G2tTlyLjlWXi7/ACkqHDld8TSbXvxm9/8BqFQCFu3bsWePXuQkZGBwsJCHDx4EEePHoVhGHjwwQdx+vRpvPfeewgEAgiHwwBitVu/34+cnBx88cUX2LNnDyKRCP7rv/4LALB69WokJSVhx44deOGFF+D3++H1erF582YcO3YM69evh9/vx3PPPYeRI0di1qxZsrn4wIED+PWvf423334bRITf/e53cDqd2LhxI06cOIGnn34aW7ZsQXV1NaZPn468vDykpKSgpqYGAFBTUyNP3ieeeEJ+DgBPPvkk9u7di88++wxr166FzWbDiBEjcPjwYRw8eBAulwtutxtbtmzBrbfeis6dO1uOY05ODt555x3s378ft9xyC0aMGIGDBw/iyJEj2L9/Pz766CP8z//8D4gI8+bNw4EDBwAAL730EnRdR0ZGBvbt24dZs2ahe/fuAICvvvoKffr0gaqq2LJlC86ePYu9e/ciLy8Py5cvx3vvvYdQKATDMPDEE0/gzJkzWL9+PZKSknDo0CG88847+OCDD7Bv3z784he/kDX1/fv3Y+/evXC5XFi/fj3+/ve/4/XXX4eqqpg6dSqOHz+OZ599FosXL8bRo0dx4MAB9OjRA4qi4OWXX5bH2WyO37t3r+W8PnXqFNLS0mRBcMMNN0BRFOzatQunT5/GK6+8gqeeegoffvgh1q1bJ5sr33rrLRw5cgQvv/wygsEgli5diq5du2LRokWysFmxYgWmT5+Onj17Yvv27cjLy4NhGPL8Gj9+PK666ipMmDABw4cPR1FREf7zP/8TAPDee+/JJt7q6mp89tlnKCkpwWOPPQYAmDVrFjweDyZNmtTgvH3jjTfw/vvvo7a2Fnl5eejYsSN69+4tt3n9+vU4fvw4Xn31VdkqYO6rN954A6+//jo+++wz/PWvf8XQoUPhcDjwzDPP4PX3P0Vai/bwtOyNvFmrEZ31NBxZbUCKirzZa5F3++/hKu0DZ15H+MrHwB4phC0QRWDwDGTN34TgVbOh+sIIVz2I/Ns2oWr2AtmEBQBXDR8JV35HpE1ZhvQbVsIRLYGw2RGdsRpZ8zfBnloIoTkRmfRLhMc9EGviVDWkTXkMGeMfwKzb7sKBAwfwySefoGPHjvD5fJg9ezYAYPv27fK8XrBgAVwuF6ZPn47Dhw/jq6++QkpKCm6++WaM+OW2WKEvFDiyy2L5rmvSS712CbxdroGrtA8y5zyHzFt/i6z5mxAYdBOE7kF43AMo7DcSbdq0QSAQwObNm/Hss89i27Zt+PTTT/GPf/wDffv2haZp2Lx5MwDgzJkzqKmpwZw5c6AoCg4ePIivvvoK7356BJV3/QqhgddD0T2IjH8I/t4TIWwOCN2F9DH3YtT/WQ9dd+LFF19EQUEBRo0ahdzcXJw6dQpA7Kbmvvvuw7Zt2+B0OlFRUYGRI0eipqYGu3fvxq5du3DixAkcOnQIdt2AzZOMjNnPIHPe80idshSpkx5F+o2/RnDIHAi7E4rTi+j0Vci89bewRwqguPxwlw1CaNjtEA4X8mavxdJte/HCCy9g//79qKmpwfPPPw8iwp133omTJ0/iq6++Qv/+/dGhQwccOXIEZ86cwR/+8AdLHDpy5AjefPNNEBH+9Kc/oUePHrjttttQW1uLpUuXYsyYMRg2bBheeumlRmOaqdnAt3z5csv/5vOWP/7xj5bPa2pqLHd/iqLA4XBg2rRp8jszZsyQNSqPx4PnnntOTquursbAgQPhcrmQXte0ZJ443k7DoDi98i5L6B6ERt6DrPmbkDrpl1CMcy/MkGqDs6AL8m5+Gp8fPwkAWLRoEVJSUuDxeFBWVobRo0fL9U6fPl3eqSuKgtzcXOzZswdALAiYTWZmtdput8t5161bB6/XKwfVDYfDeOihh+T03r17Q1VVuFwu2Gw2aJqGQYMGAQB27NjRoFYTDAblvM888wyKiorgcrngdDqRlpaGd99999xBa6TpxNS9e3d4vV5Zc+nZsyfuuOMOOb1169aW4+R0OmW+iGJNhS6XS9bI2rRpYznWza07/jNVVeF0OrFw4UJs3bpVLjv+2dKYMWNQW1sr2+mdTqecruu6rJE9/PDDSE5OhmEY6NatGxYsWIBu3bpZjkVpaalsnjFvQABgyZIlsiVBCAGfz4clS5bIec3jrCiK3G6XyyWn33///fIccDqdeOSRR+S0v/3tb+jUqZN841LTNMt5bW6Xy+WSz7nNNzonTpxoeWZsGAbuv/9+Oe/Ro0dxzTXXyNrpPffcI9+sNpcb/zJOMBiU083nHWYyj+m+ffuwZs0aZGdnyxr56NGjsX///gbnj6Zp8Pv9WLt2rZxmzmsYhrwBjkajePHFFwEAH374IYqKW8hr1W54UDH7ISzdthefHz+JP/9tH/I69weRgKK74es+TjYJ5sx/Hp5W/SDqjr/dbsf1118v1/3555+j64CroRq+2FuknmToOe1kzSp9xhrYAuYzWBF7zlRxM4p//ALGzrhDtp6Yj2pmzJghbxjNFh+Xy4VBgwZh2LBhlmtmypQp5/a1okLPLkN05ppYC1Pc26zxyddtTKzW26Jn7FkYCahq7B0Cs5xYsmQJIpGIbMXweDxYvHixXO/KlSsbLHfChAkAgK1bt6K0ZSvYNDtEXU3P8CdjxI3zZdn37LPPyqbv7t27Y/fu3XLZu3btQq9eveQz/fja/ksvvYTCwsJGW/fSr38cyVfPg+oOQNgc0FJy4O89EaonaKnlnptH1L1/oeOdv/03brnllgYDkxPFfgFglhP1X0ScO3duo2WMmc6cOYPa2loMHDhQ3nyqqormNPsD9stl6qod9OKef9DF5EwIooElYVpa1eGbzxhj7JId/ucp2rCzmt7ff5yOnTxNXl2j4lQPXdMuSkF3811oPfXGx7Twhffp5JnaZssHIYh0m0p3XFlMVV2yv7G8P/XGx3T383+lM1/jt/I2hejuIaXfaD7+1b5vZfK/ZeB799MvafSKN6jm9NfvwcSpqbRuahdqHfWf/8uMse+c/1v9JT26dS+9/P8OkSCik3FRSLcpBCLqUxSiG3vnfyvlwFNvfEz/sWkPnao9f/RzqAr9uKLFdzroEX3/yuR/y8BHZN7Z7aGa0xd+a+XUFLrjyu/+ScYYO79LqTleKjP4/un9g1R7FlQbV4qqgkhVBPUtTvnWgu/l8H0qk/9tAx/R5W/WYIyx5lzO4Hs5fF/K5H/rwEd0+Zs1GGOMnfN9KJP/7QOfKdHurBhj7N/Zd7lM/s4EPsYYY+ybcPmGf2aMMcYuAw58jDHGEgoHPsYYYwmFAx9jjLGEwoGPMcZYQuHAxxhjLKFw4GOMMZZQOPAxxhhLKBz4GGOMJRQOfIwxxhIKBz7GGGMJhQMfY4yxhMKBjzHGWELhwMcYYyyhcOBjjDGWUDjwMcYYSygc+BhjjCUUDnyMMcYSCgc+xhhjCYUDH2OMsYTCgY8xxlhC4cDHGGMsoXDgY4wxllA48DHGGEsoHPgYY4wlFA58jDHGEgoHPsYYYwmFAx9jjLGEwoGPMcZYQuHAxxhjLKFw4GOMMZZQOPAxxhhLKBz4GGOMJRQOfIwxxhIKBz7GGGMJhQMfY4yxhMKBjzHGWELhwMcYYyyhcOBjjDGWUDjwMcYYSygc+BhjjCUUDnyMMcYSCgc+xhhjCYUDH2OMsYTCgY8xxlhC4cDHGGMsoXDgY4wxllA48DHGGEsoHPgYY4wlFA58jDHGEgoHPsYYYwmFAx9jjLGEwoGPMcZYQuHAxxhjLKFw4GOMMZZQOPAxxhhLKBz4GGOMJRQOfIwxxhIKBz7GGGMJhQMfY4yxhMKBjzHGWELhwMcYYyyhcOBjjDGWUDjwMcYYSygc+BhjjCUUDnyMMcYSCgc+xhhjCYUDH2OMsYTCgY8xxlhC4cDHGGMsoXDgY4wxllA48DHGGEsoHPgYY4wlFA58jDHGEgoHPsYYYwmFAx9jjLGEwoGPMcZYQuHAxxhjLKFw4GOMMZZQOPAxxhhLKBz4GGOMJRQOfIwxxhIKBz7GGGMJhQMfY4yxhMKBjzHGWELhwMcYYyyhcOBjjDGWUDjwMcYYSygc+BhjjCUUDnyMMcYSCgc+xhhjCYUDH2OMsYTCgY8xxlhC4cDHGGMsoXDgY4wxllA48DHGGEsoHPgYY4wlFA58jDHGEgoHPsYYYwmFAx9jjLGEwoGPMcZYQvn/sNwaYVjYTVoAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import urllib3\n",
    "\n",
    "def testcase():\n",
    "    http = urllib3.PoolManager()\n",
    "    r1 = http.request('GET', \"https://d3c33hcgiwev3.cloudfront.net/_eed1bd08e2fa58bbe94b24c06a20dcdb_huffman.txt?Expires=1563408000&Signature=in89gZIUo2zqM~jXYoTJVkE1SAqbqYOt4yF9gHQN0CLE4py~WgfywvjKLNmVtvzm32-ZHbaJLbcjELUEhx13jwoRUgH7~RUzkz0~OZ~c8lAbrC6ivmP3i5lYkeIA6VwHxTmP8v0hFOlZuoEEYw0Af1UK1yPEnS5HwEQhBYIc300_&Key-Pair-Id=APKAJLTNE6QMUY6HBC5A\")\n",
    "    IntegerMatrixStringJoin = r1.data.decode('utf8').split('\\n')\n",
    "    IntegerMatrixStringJoin.remove('')\n",
    "    n = int(IntegerMatrixStringJoin[0])\n",
    "    IntegerMatrixStringJoin.remove(IntegerMatrixStringJoin[0])\n",
    "    symbols = []\n",
    "    for i in range(n):\n",
    "        symbols.append(str(i+1))\n",
    "        IntegerMatrixStringJoin[i] = int(IntegerMatrixStringJoin[i])\n",
    "    return symbols, IntegerMatrixStringJoin\n",
    "\n",
    "\n",
    "symbols, weights = testcase()\n",
    "output = huffmans_code_heap(symbols, weights)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "maximum length of a codeword is 19\n",
      " minimum length of a codeword is 9\n"
     ]
    }
   ],
   "source": [
    "maxlen = 0\n",
    "minlen = float('inf')\n",
    "for o in output:\n",
    "    if len(o[1]['weight']) > maxlen:\n",
    "        maxlen = len(o[1]['weight'])\n",
    "    if len(o[1]['weight']) < minlen:\n",
    "        minlen = len(o[1]['weight'])\n",
    "\n",
    "print(\"maximum length of a codeword is {}\\n minimum length of a codeword is {}\".format(maxlen, minlen))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# XXV. INTRODUCTION TO DYNAMIC PROGRAMMING \n",
    "Indeed, even more than usual, the dynamic programming paradigm takes practice to perfect. People find it counterintuitive at first, and they often struggle to apply the paradigm to problems that they haven's seen before. But here's the good news, dynamic programming is relatively formulaic,certainly more so than our recent study of greedy algorithms, and it's something that you can get a hang of. \n",
    "\n",
    "And the key approach in this new paradigm is to first reason about the structure of an optimal solution.\n",
    "So in fact, in much of our discussion of both divide and conquer and greedy algorithms, this kind of reasoning was implicit. With dynamic programming, we're going to make it systematic. For example, implicit in the correctness of many of divide and conquer algorithm is the fact that an optimal solution to the whole problem has to be expressible, has to be constructable in a prescribed way from solutions to smaller sub-problems. So, what's the motivation for doing thisthought experiment, trying to understand what the optimal solution could possibly look like? Well, the plan is we're going to narrow the possible candidates for the optimal solution down to a relatively small set of candidates. With a small set, we can get away with brute force search to pick the best one. So, one lesson you learn once you get good at dynamic programming, is that it's not at all circular to reason about the very object that you're trying to compute.\n",
    "\n",
    "### Max weight independent set problem using Dynamic programming\n",
    "In this problem, we're going to restrict our attention merely to path graphs.  That's graphs that consist solely of a path on some number n of vertices. The only other part of the input is a single non-negative number per vertex. We're going to call these weights. The responsibility of the algorithm is going to be to output an independent set. So in the context of a simple path graph, it just means you gotta return some of the vertices and always avoiding consecutive pairs of vertices. That's the max weight independence set problem.\n",
    "\n",
    "There's only two possibilities for what the optimal solution could possibly look like, in terms of optimal solutions of smaller sub problems. So, a corollary of this is that if a little birdie told us which case we were in, whether or not V sub n, V sub n was in the optimal solution, we could just complete this by recursing on the appropriate sub-problem. The little birdie tells us the optimal solution doesn't have Vn we just recurse on G prime. If the little birdie tells us v sub n is in the optimal solution, we recurse on G double prime and then add V sub n to the result. Now, of course, there is no little birdie and we have no idea whether this right-most vertex is in the optimal solution or not. But hey, there is only two possibilities, right? Here is an idea. Maybe it seems crazy, but why not try both possibilities and just return whichever one is better? Why do I suggest that maybe this is crazy? Well, if you stare at this and you think about it and you think about the ramifications of trying both possibilities as you recursed down the graph, this may start feeling a little bit like brute force search. And, in fact it is. This is just a recursive organization of a brute force search. Nevertheless, as we'll see in the next video, if we're smart about eliminating redundancy, we can actually implement this idea in a linear time.\n",
    "\n",
    "So while this kind of recursive algorithm, follows the template of divide and conquer pretty much exactly. the running time is blown up to exponential. And the reason for that difference is, in our divide an conquer algorithms, think of Merge Sort as a canonical example, we made a ton of progress before we recursed. Right? We threw out half of the array, 50% of the stuff before we bothered with any recursion. How much progress are we making in this algorithm? Well, very little. It's positive progress, but very small. We throw out either one or two vertices out of maybe this graph with say a million vertices before recursing. So we're branching by a factor two and making very little progress before each branch. That's why we give this exponential running time rather than something more in the neighborhood of n log n. \n",
    "\n",
    "    But the number of distinct problems we can solve is uperbounded by O(n)\n",
    "\n",
    "From this, we conclude that the exponential running time of the previous algorithm arises solely from the spectacular redundancy of solving exactly the same sub-problem from scratch, over and over and over and over again. \n",
    "\n",
    " So an obvious way to speed up this algorithm, to speed it up dramatically is to simply cache the results of a sub-problem the first time you see it. Then you can look it up in some array, constant time, at any point later on in the algorithm. There is a word for this, I won't really use it in this class, but just so you that know what it is, it's called *memoization*.\n",
    "\n",
    "Now when you do a recursive call and you're handed the first I vertices of the graph, and again remember that we know that the sub-problem has to look like the first I vertices of the graph for sub I. You check the array, if it's already been filled in, if you already know the answer, great. You just return it and count the time, you don't bother to resolve. If this is the first time you've ever seen. this sub problem then you recurse and you solve it, as as we saw, as we suggested in the previous slot. So with this simple memoization fixed, this action, this algorithm is linear time. \n",
    "\n",
    "### Principles of Dynamic programming\n",
    "So the first property that you want yourcollection of subproblems to possess is it shouldn't be too big. It shouldn't have too many different subproblems. The reason being is, in the best case scenario, you're going to be spendingconstant time solving each of those subproblems, so the number of subproblems is a lower bound than the running time of your algorithm. Now, in the Maximum Independent Set example, we did great. We had merely a linear number of subproblems, and we did indeed get away with a mere constant work for each of those subproblems, giving us our linear running time bound overall. \n",
    "\n",
    "The second property you want and this one's really the kicker, is there should be a notion of smaller subproblems and larger subproblems. In the context of independence sets of path graphs this was really easy to understand. The subproblems were prefixes of the original graph and the more vertices you had, the bigger the subproblem. So in general, in dynamic programming, you systematically solve all of the subproblems beginning with the smallest ones and moving on to larger and larger subproblems. And for this to work, it better be the case that, at a given subproblem. Given the solutions to all of the smaller sub problems it's easier to confer what the solution to the current sub problem is. That is solutions to previous sub problems are sufficient to quickly and correctly compute the solution to the current sub problem.\n",
    "\n",
    "So the third property, you probably won't have to worry about much. Usually this just takes care of itself. But needless to say, after you've done the work of solving all of your sub problems, you better be able to answer the original question. This property is usually automatically satisfied because in most cases, not all, but in most cases the original problem is simply the biggest of all of your subproblems. Notice this is exactly how things worked in the independent sets. Our biggest subproblem G sub N was just the original graph. So once we fill up the whole table, boom. Waiting for us in the final entry was the desired solution to the original problem.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Weights : [0, 8, 8, 9, 16, 16, 17, 24]\n",
      "Max Weight Independent Set : [8, 8, 8]\n",
      "Vertices are: [7, 4, 1]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[7, 4, 1]"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import networkx as nx\n",
    "import heapq\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "import copy \n",
    "\n",
    "def max_wis_recursive(path_graph, A, index): # A index\n",
    "    #print(\"path_graph {}, A {}, index {}\".format(path_graph, A, index))\n",
    "    if len(path_graph) == 0:\n",
    "        return A[0]\n",
    "    elif len(path_graph) == 1:\n",
    "        return A[1]\n",
    "    if A[index-1] != None:\n",
    "        aexcluding = A[index-1]\n",
    "    else:\n",
    "        aexcluding = max_wis_recursive(path_graph[:-1], A, index-1)\n",
    "    if A[index-2] != None:\n",
    "        aincluding = A[index-2]\n",
    "    else:\n",
    "        aincluding = max_wis_recursive(path_graph[:-2], A, index-2)\n",
    "    #print(\"aexcluding {},  aincluding {} ; path_graph {}, A {}, index {}\".format(aexcluding , aincluding, path_graph, A, index))\n",
    "    if aexcluding >= (aincluding + path_graph[-1]):\n",
    "        A[index] = aexcluding\n",
    "    else:\n",
    "        A[index] = aincluding + path_graph[-1]\n",
    "    return A[index]\n",
    "    \n",
    " \n",
    "def reconstruction_algorithm(S, V, arr, A):\n",
    "    i = len(A)-1\n",
    "    while i >= 2:\n",
    "        #print(\"i :{} , A[i-1]: {} >= A[i-2]: {} + arr[i-1]: {} \".format(i, A[i-1] ,A[i-2] ,arr[i-1]))\n",
    "        if A[i-1] >= A[i-2] + arr[i-1]:\n",
    "            if i == 2:\n",
    "                S.append(arr[0])\n",
    "                V.append(1)\n",
    "            i -= 1\n",
    "        else:\n",
    "            S.append(arr[i-1])\n",
    "            V.append(i)\n",
    "            if i == 3:\n",
    "                S.append(arr[0])\n",
    "                V.append(1)\n",
    "            i -= 2\n",
    "    return S,V\n",
    "\n",
    "    \n",
    "def max_weight_independent_set(array):\n",
    "    idx = len(array)\n",
    "    A = [None]*(idx+1)  # max weight\n",
    "    A[0] = 0\n",
    "    A[1] = array[0]\n",
    "    max_wis_recursive(array, A, idx)\n",
    "    print(\"Weights : {}\".format(A))\n",
    "    S = []\n",
    "    V = [] #vertices added starting from 1\n",
    "    S, V = reconstruction_algorithm(S, V, array, A)\n",
    "    print(\"Max Weight Independent Set : {}\\nVertices are: {}\".format(S, V))\n",
    "    return V\n",
    "    \n",
    " \n",
    "\n",
    "\n",
    "#max_weight_independent_set([1, 4])    \n",
    "#max_weight_independent_set([1, 4, 5, 4])    \n",
    "max_weight_independent_set([8, 1, 1, 8, 1, 1, 8])\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Weights : [0, 10, 280, 628, 1042, 1536, 1536, 1570, 1595, 1847, 1847, 2626]\n",
      "Max Weight Independent Set : [779, 277, 34, 908, 618, 10]\n",
      "Vertices are: [11, 9, 7, 5, 3, 1]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[11, 9, 7, 5, 3, 1]"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max_weight_independent_set([10, 280, 618, 762, 908, 409, 34, 59, 277, 246, 779])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Challenge problem\n",
    "In this programming problem you'll code up the dynamic programming algorithm for computing a maximum-weight independent set of a path graph.\n",
    "\n",
    "Download the text file below: mwis.txt\n",
    "\n",
    "This file describes the weights of the vertices in a path graph (with the weights listed in the order in which vertices appear in the path). It has the following format:\n",
    "\n",
    "[number_of_vertices]\n",
    "\n",
    "[weight of first vertex]\n",
    "\n",
    "[weight of second vertex]\n",
    "\n",
    "...\n",
    "\n",
    "For example, the third line of the file is \"6395702,\" indicating that the weight of the second vertex of the graph is 6395702.\n",
    "\n",
    "Your task in this problem is to run the dynamic programming algorithm (and the reconstruction procedure) from lecture on this data set. The question is: of the vertices 1, 2, 3, 4, 17, 117, 517, and 997, which ones belong to the maximum-weight independent set? (By \"vertex 1\" we mean the first vertex of the graph---there is no vertex 0.) In the box below, enter a 8-bit string, where the ith bit should be 1 if the ith of these 8 vertices is in the maximum-weight independent set, and 0 otherwise. For example, if you think that the vertices 1, 4, 17, and 517 are in the maximum-weight independent set and the other four vertices are not, then you should enter the string 10011010 in the box below.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10100110\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/aishwaya/anaconda2/envs/python_3_6/lib/python3.6/site-packages/urllib3/connectionpool.py:847: InsecureRequestWarning: Unverified HTTPS request is being made. Adding certificate verification is strongly advised. See: https://urllib3.readthedocs.io/en/latest/advanced-usage.html#ssl-warnings\n",
      "  InsecureRequestWarning)\n"
     ]
    }
   ],
   "source": [
    "import urllib3\n",
    "\n",
    "def testcase():\n",
    "    http = urllib3.PoolManager()\n",
    "    r1 = http.request('GET', \"https://d3c33hcgiwev3.cloudfront.net/_790eb8b186eefb5b63d0bf38b5096873_mwis.txt?Expires=1563408000&Signature=AbPsyoBnPleWz9iqcqpDcrEfYTdR1QmBqmPsjzRRzwBhmFfmjBgGrP2wLN0mNyXRGZ3j2b66WL4NI7uMo8t2KepP8xu6EmS0vobz9kmvM--gDrNB5KnOsDnKU-kuixlO5iVyW3XGzadn0GhmbwPABI9EzC~tjSHVCHRFIhww~6o_&Key-Pair-Id=APKAJLTNE6QMUY6HBC5A\")\n",
    "    IntegerMatrixStringJoin = r1.data.decode('utf8').split('\\n')\n",
    "    IntegerMatrixStringJoin.remove('')\n",
    "    n = int(IntegerMatrixStringJoin[0])\n",
    "    IntegerMatrixStringJoin.remove(IntegerMatrixStringJoin[0])\n",
    "    for i in range(n):\n",
    "        IntegerMatrixStringJoin[i] = int(IntegerMatrixStringJoin[i])\n",
    "    return IntegerMatrixStringJoin\n",
    "\n",
    "\n",
    "vertices = max_weight_independent_set(testcase())\n",
    "result = ''\n",
    "for v in [1, 2, 3, 4, 17, 117, 517, 997]:\n",
    "    if v in vertices:\n",
    "        result += '1'\n",
    "    else:\n",
    "        result += '0'\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}