tutorial_full-networkx-not-mine.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- -*- coding: utf-8 -*- -->\n",
    "## Tutorial\n",
    "\n",
    "This guide can help you start working with NetworkX.\n",
    "\n",
    "### Creating a graph\n",
    "\n",
    "Create an empty graph with no nodes and no edges."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import networkx as nx\n",
    "G = nx.Graph()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By definition, a `Graph` is a collection of nodes (vertices) along with\n",
    "identified pairs of nodes (called edges, links, etc).  In NetworkX, nodes can\n",
    "be any hashable object e.g., a text string, an image, an XML object, another\n",
    "Graph, a customized node object, etc.\n",
    "\n",
    "# Nodes\n",
    "\n",
    "The graph `G` can be grown in several ways.  NetworkX includes many graph\n",
    "generator functions and facilities to read and write graphs in many formats.\n",
    "To get started though we’ll look at simple manipulations.  You can add one node\n",
    "at a time,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "G.add_node(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "add a list of nodes,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "G.add_nodes_from([2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or add any iterable container of nodes. You can also add nodes along with node\n",
    "attributes if your container yields 2-tuples (node, node_attribute_dict).\n",
    "Node attributes are discussed further below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "H = nx.path_graph(10)\n",
    "G.add_nodes_from(H)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that `G` now contains the nodes of `H` as nodes of `G`.\n",
    "In contrast, you could use the graph `H` as a node in `G`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "G.add_node(H)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The graph `G` now contains `H` as a node.  This flexibility is very powerful as\n",
    "it allows graphs of graphs, graphs of files, graphs of functions and much more.\n",
    "It is worth thinking about how to structure your application so that the nodes\n",
    "are useful entities.  Of course you can always use a unique identifier in `G`\n",
    "and have a separate dictionary keyed by identifier to the node information if\n",
    "you prefer.\n",
    "\n",
    "# Edges\n",
    "\n",
    "`G` can also be grown by adding one edge at a time,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "G.add_edge(1, 2)\n",
    "e = (2, 3)\n",
    "G.add_edge(*e)  # unpack edge tuple*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "by adding a list of edges,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "G.add_edges_from([(1, 2), (1, 3)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or by adding any ebunch of edges.  An *ebunch* is any iterable\n",
    "container of edge-tuples.  An edge-tuple can be a 2-tuple of nodes or a 3-tuple\n",
    "with 2 nodes followed by an edge attribute dictionary, e.g.,\n",
    "`(2, 3, {'weight': 3.1415})`.  Edge attributes are discussed further below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "G.add_edges_from(H.edges)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are no complaints when adding existing nodes or edges. For example,\n",
    "after removing all nodes and edges,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "G.clear()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we add new nodes/edges and NetworkX quietly ignores any that are\n",
    "already present."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "G.add_edges_from([(1, 2), (1, 3)])\n",
    "G.add_node(1)\n",
    "G.add_edge(1, 2)\n",
    "G.add_node(\"spam\")        # adds node \"spam\"\n",
    "G.add_nodes_from(\"spam\")  # adds 4 nodes: 's', 'p', 'a', 'm'\n",
    "G.add_edge(3, 'm')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At this stage the graph `G` consists of 8 nodes and 3 edges, as can be seen by:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "G.number_of_nodes()\n",
    "G.number_of_edges()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can examine the nodes and edges. Four basic graph properties facilitate\n",
    "reporting: `G.nodes`, `G.edges`, `G.adj` and `G.degree`.  These\n",
    "are set-like views of the nodes, edges, neighbors (adjacencies), and degrees\n",
    "of nodes in a graph. They offer a continually updated read-only view into\n",
    "the graph structure. They are also dict-like in that you can look up node\n",
    "and edge data attributes via the views and iterate with data attributes\n",
    "using methods `.items()`, `.data('span')`.\n",
    "If you want a specific container type instead of a view, you can specify one.\n",
    "Here we use lists, though sets, dicts, tuples and other containers may be\n",
    "better in other contexts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(G.nodes)\n",
    "list(G.edges)\n",
    "list(G.adj[1])  # or list(G.neighbors(1))\n",
    "G.degree[1]  # the number of edges incident to 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One can specify to report the edges and degree from a subset of all nodes\n",
    "using an *nbunch*. An *nbunch* is any of: None (meaning all nodes), a node,\n",
    "or an iterable container of nodes that is not itself a node in the graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DegreeView({2: 1, 3: 2})"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "G.edges([2, 'm'])\n",
    "G.degree([2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One can remove nodes and edges from the graph in a similar fashion to adding.\n",
    "Use methods\n",
    "`Graph.remove_node()`,\n",
    "`Graph.remove_nodes_from()`,\n",
    "`Graph.remove_edge()`\n",
    "and\n",
    "`Graph.remove_edges_from()`, e.g."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "G.remove_node(2)\n",
    "G.remove_nodes_from(\"spam\")\n",
    "list(G.nodes)\n",
    "G.remove_edge(1, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When creating a graph structure by instantiating one of the graph\n",
    "classes you can specify data in several formats."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "G.add_edge(1, 2)\n",
    "H = nx.DiGraph(G)   # create a DiGraph using the connections from G\n",
    "list(H.edges())\n",
    "edgelist = [(0, 1), (1, 2), (2, 3)]\n",
    "H = nx.Graph(edgelist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# What to use as nodes and edges\n",
    "\n",
    "You might notice that nodes and edges are not specified as NetworkX\n",
    "objects.  This leaves you free to use meaningful items as nodes and\n",
    "edges. The most common choices are numbers or strings, but a node can\n",
    "be any hashable object (except `None`), and an edge can be associated\n",
    "with any object `x` using `G.add_edge(n1, n2, object=x)`.\n",
    "\n",
    "As an example, `n1` and `n2` could be protein objects from the RCSB Protein\n",
    "Data Bank, and `x` could refer to an XML record of publications detailing\n",
    "experimental observations of their interaction.\n",
    "\n",
    "We have found this power quite useful, but its abuse\n",
    "can lead to unexpected surprises unless one is familiar with Python.\n",
    "If in doubt, consider using `convert_node_labels_to_integers()` to obtain\n",
    "a more traditional graph with integer labels.\n",
    "\n",
    "# Accessing edges and neighbors\n",
    "\n",
    "In addition to the views `Graph.edges()`, and `Graph.adj()`,\n",
    "access to edges and neighbors is possible using subscript notation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "G[1]  # same as G.adj[1]\n",
    "G[1][2]\n",
    "G.edges[1, 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can get/set the attributes of an edge using subscript notation\n",
    "if the edge already exists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "G.add_edge(1, 3)\n",
    "G[1][3]['color'] = \"blue\"\n",
    "G.edges[1, 2]['color'] = \"red\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fast examination of all (node, adjacency) pairs is achieved using\n",
    "`G.adjacency()`, or `G.adj.items()`.\n",
    "Note that for undirected graphs, adjacency iteration sees each edge twice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 0.125)\n",
      "(2, 1, 0.125)\n",
      "(3, 4, 0.375)\n",
      "(4, 3, 0.375)\n"
     ]
    }
   ],
   "source": [
    "FG = nx.Graph()\n",
    "FG.add_weighted_edges_from([(1, 2, 0.125), (1, 3, 0.75), (2, 4, 1.2), (3, 4, 0.375)])\n",
    "for n, nbrs in FG.adj.items():\n",
    "   for nbr, eattr in nbrs.items():\n",
    "       wt = eattr['weight']\n",
    "       if wt < 0.5: print('(%d, %d, %.3f)' % (n, nbr, wt))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convenient access to all edges is achieved with the edges property."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 0.125)\n",
      "(3, 4, 0.375)\n"
     ]
    }
   ],
   "source": [
    "for (u, v, wt) in FG.edges.data('weight'):\n",
    "    if wt < 0.5: print('(%d, %d, %.3f)' % (u, v, wt))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Adding attributes to graphs, nodes, and edges\n",
    "\n",
    "Attributes such as weights, labels, colors, or whatever Python object you like,\n",
    "can be attached to graphs, nodes, or edges.\n",
    "\n",
    "Each graph, node, and edge can hold key/value attribute pairs in an associated\n",
    "attribute dictionary (the keys must be hashable).  By default these are empty,\n",
    "but attributes can be added or changed using `add_edge`, `add_node` or direct\n",
    "manipulation of the attribute dictionaries named `G.graph`, `G.nodes`, and\n",
    "`G.edges` for a graph `G`.\n",
    "\n",
    "## Graph attributes\n",
    "\n",
    "Assign graph attributes when creating a new graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'day': 'Friday'}"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "G = nx.Graph(day=\"Friday\")\n",
    "G.graph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or you can modify attributes later"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'day': 'Monday'}"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "G.graph['day'] = \"Monday\"\n",
    "G.graph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Node attributes\n",
    "\n",
    "Add node attributes using `add_node()`, `add_nodes_from()`, or `G.nodes`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NodeDataView({1: {'room': 714, 'time': '5pm'}, 3: {'time': '2pm'}})"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "G.add_node(1, time='5pm')\n",
    "G.add_nodes_from([3], time='2pm')\n",
    "G.nodes[1]\n",
    "G.nodes[1]['room'] = 714\n",
    "G.nodes.data()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that adding a node to `G.nodes` does not add it to the graph, use\n",
    "`G.add_node()` to add new nodes. Similarly for edges.\n",
    "\n",
    "# Edge Attributes\n",
    "\n",
    "Add/change edge attributes using `add_edge()`, `add_edges_from()`,\n",
    "or subscript notation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "G.add_edge(1, 2, weight=4.7 )\n",
    "G.add_edges_from([(3, 4), (4, 5)], color='red')\n",
    "G.add_edges_from([(1, 2, {'color': 'blue'}), (2, 3, {'weight': 8})])\n",
    "G[1][2]['weight'] = 4.7\n",
    "G.edges[3, 4]['weight'] = 4.2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The special attribute `weight` should be numeric as it is used by\n",
    "algorithms requiring weighted edges.\n",
    "\n",
    " Directed graphs\n",
    "\n",
    "The `DiGraph` class provides additional properties specific to\n",
    "directed edges, e.g.,\n",
    "`DiGraph.out_edges()`, `DiGraph.in_degree()`,\n",
    "`DiGraph.predecessors()`, `DiGraph.successors()` etc.\n",
    "To allow algorithms to work with both classes easily, the directed versions of\n",
    "`neighbors()` is equivalent to `successors()` while `degree` reports\n",
    "the sum of `in_degree` and `out_degree` even though that may feel\n",
    "inconsistent at times."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DG = nx.DiGraph()\n",
    "DG.add_weighted_edges_from([(1, 2, 0.5), (3, 1, 0.75)])\n",
    "DG.out_degree(1, weight='weight')\n",
    "DG.degree(1, weight='weight')\n",
    "list(DG.successors(1))\n",
    "list(DG.neighbors(1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some algorithms work only for directed graphs and others are not well\n",
    "defined for directed graphs.  Indeed the tendency to lump directed\n",
    "and undirected graphs together is dangerous.  If you want to treat\n",
    "a directed graph as undirected for some measurement you should probably\n",
    "convert it using `Graph.to_undirected()` or with"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "H = nx.Graph(G)  # convert G to undirected graph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multigraphs\n",
    "\n",
    "NetworkX provides classes for graphs which allow multiple edges\n",
    "between any pair of nodes.  The `MultiGraph` and\n",
    "`MultiDiGraph`\n",
    "classes allow you to add the same edge twice, possibly with different\n",
    "edge data.  This can be powerful for some applications, but many\n",
    "algorithms are not well defined on such graphs.\n",
    "Where results are well defined,\n",
    "e.g., `MultiGraph.degree()` we provide the function.  Otherwise you\n",
    "should convert to a standard graph in a way that makes the measurement\n",
    "well defined."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MG = nx.MultiGraph()\n",
    "MG.add_weighted_edges_from([(1, 2, 0.5), (1, 2, 0.75), (2, 3, 0.5)])\n",
    "dict(MG.degree(weight='weight'))\n",
    "GG = nx.Graph()\n",
    "for n, nbrs in MG.adjacency():\n",
    "   for nbr, edict in nbrs.items():\n",
    "       minvalue = min([d['weight'] for d in edict.values()])\n",
    "       GG.add_edge(n, nbr, weight = minvalue)\n",
    "\n",
    "nx.shortest_path(GG, 1, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Graph generators and graph operations\n",
    "\n",
    "In addition to constructing graphs node-by-node or edge-by-edge, they\n",
    "can also be generated by\n",
    "\n",
    "1. Applying classic graph operations, such as:\n",
    "\n",
    "   ```\n",
    "   subgraph(G, nbunch)      - induced subgraph view of G on nodes in nbunch\n",
    "   union(G1,G2)             - graph union\n",
    "   disjoint_union(G1,G2)    - graph union assuming all nodes are different\n",
    "   cartesian_product(G1,G2) - return Cartesian product graph\n",
    "   compose(G1,G2)           - combine graphs identifying nodes common to both\n",
    "   complement(G)            - graph complement\n",
    "   create_empty_copy(G)     - return an empty copy of the same graph class\n",
    "   convert_to_undirected(G) - return an undirected representation of G\n",
    "   convert_to_directed(G)   - return a directed representation of G\n",
    "   ```\n",
    "\n",
    "1. Using a call to one of the classic small graphs, e.g.,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "petersen = nx.petersen_graph()\n",
    "tutte = nx.tutte_graph()\n",
    "maze = nx.sedgewick_maze_graph()\n",
    "tet = nx.tetrahedral_graph()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Using a (constructive) generator for a classic graph, e.g.,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "K_5 = nx.complete_graph(5)\n",
    "K_3_5 = nx.complete_bipartite_graph(3, 5)\n",
    "barbell = nx.barbell_graph(10, 10)\n",
    "lollipop = nx.lollipop_graph(10, 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Using a stochastic graph generator, e.g.,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "er = nx.erdos_renyi_graph(100, 0.15)\n",
    "ws = nx.watts_strogatz_graph(30, 3, 0.1)\n",
    "ba = nx.barabasi_albert_graph(100, 5)\n",
    "red = nx.random_lobster(100, 0.9, 0.9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Reading a graph stored in a file using common graph formats,\n",
    "   such as edge lists, adjacency lists, GML, GraphML, pickle, LEDA and others."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "nx.write_gml(red, \"path.to.file\")\n",
    "mygraph = nx.read_gml(\"path.to.file\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For details on graph formats see Reading and writing graphs\n",
    "and for graph generator functions see Graph generators\n",
    "\n",
    "# Analyzing graphs\n",
    "\n",
    "The structure of `G` can be analyzed using various graph-theoretic\n",
    "functions such as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 0, 2: 0, 3: 0, 'spam': 0}"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "G = nx.Graph()\n",
    "G.add_edges_from([(1, 2), (1, 3)])\n",
    "G.add_node(\"spam\")       # adds node \"spam\"\n",
    "list(nx.connected_components(G))\n",
    "sorted(d for n, d in G.degree())\n",
    "nx.clustering(G)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some functions with large output iterate over (node, value) 2-tuples.\n",
    "These are easily stored in a [dict](https://docs.python.org/2/library/stdtypes.html#dict) structure if you desire."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: [3, 1], 2: [3, 1, 2], 3: [3]}"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sp = dict(nx.all_pairs_shortest_path(G))\n",
    "sp[3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See Algorithms for details on graph algorithms\n",
    "supported.\n",
    "\n",
    "# Drawing graphs\n",
    "\n",
    "NetworkX is not primarily a graph drawing package but basic drawing with\n",
    "Matplotlib as well as an interface to use the open source Graphviz software\n",
    "package are included.  These are part of the `networkx.drawing` module and will\n",
    "be imported if possible.\n",
    "\n",
    "First import Matplotlib’s plot interface (pylab works too)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may find it useful to interactively test code using `ipython -pylab`,\n",
    "which combines the power of ipython and matplotlib and provides a convenient\n",
    "interactive mode.\n",
    "\n",
    "To test if the import of `networkx.drawing` was successful draw `G` using one of"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x154bd09b5690>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "G = nx.petersen_graph()\n",
    "plt.subplot(121)\n",
    "nx.draw(G, with_labels=True, font_weight='bold')\n",
    "plt.subplot(122)\n",
    "nx.draw_shell(G, nlist=[range(5, 10), range(5)], with_labels=True, font_weight='bold')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "when drawing to an interactive display.  Note that you may need to issue a\n",
    "Matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "command if you are not using matplotlib in interactive mode (see\n",
    "[Matplotlib FAQ](http://matplotlib.org/faq/installing_faq.html#matplotlib-compiled-fine-but-nothing-shows-up-when-i-use-it)\n",
    ")."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x154bce95fad0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "options = {\n",
    "    'node_color': 'black',\n",
    "    'node_size': 100,\n",
    "    'width': 3,\n",
    "}\n",
    "plt.subplot(221)\n",
    "nx.draw_random(G, **options)\n",
    "plt.subplot(222)\n",
    "nx.draw_circular(G, **options)\n",
    "plt.subplot(223)\n",
    "nx.draw_spectral(G, **options)\n",
    "plt.subplot(224)\n",
    "nx.draw_shell(G, nlist=[range(5,10), range(5)], **options)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can find additional options via `draw_networkx()` and\n",
    "layouts via `layout`.\n",
    "You can use multiple shells with `draw_shell()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x154bce90d410>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "G = nx.dodecahedral_graph()\n",
    "shells = [[2, 3, 4, 5, 6], [8, 1, 0, 19, 18, 17, 16, 15, 14, 7], [9, 10, 11, 12, 13]]\n",
    "nx.draw_shell(G, nlist=shells, **options)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To save drawings to a file, use, for example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeEAAAFCCAYAAADGwmVOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzs3XlczPkfB/DXdGkSFUmp5MpKB+tulftWVNZuVixilbBsSHb3t46ljdy61rnOHClXhGWdS+WqKIlIqxSlqOmcz++P2dqia2a+M985Ps/HYx5pmvl836Np3t/P5/v5vD8cQggBRVEURVFSp8J2ABRFURSlrGgSpiiKoiiW0CRMURRFUSyhSZiiKIqiWEKTMEVRFEWxhCZhiqIoimIJTcIURVEUxRKahCmKoiiKJTQJUxRFURRLaBKmKIqiKJbQJExRFEVRLKFJmKIoiqJYQpMwRVEURbGEJmGKoiiKYglNwhRFURTFEpqEKYqiKIolNAlTFEVRFEvU2A6AoqhGys4G9uwB4uOB/HxARwewsQGmTwdatWI7OoqiRMAhhBC2g6Aoqh6xsYCfH3D2rOD74uL/fsblAoQAo0cDvr5A797sxEhRlEhoEqYoWRYcDCxaBPB4gmRbFw5HkJADAgBPT+nFR1GUWOhwNEXJqsoEXFTU8GMJETxu0SLB9zQRU5RcoD1hipJFsbHAoEGNS8Af09ICrlwBevViPCyKophFZ0dTlCzy8xMMQYuCxxM8n6IomUd7whQla7KzATOzmhOwhKWpCaSn01nTFCXjaE+YomTNnj3it8HhMNMORVESRZMwRcma+HjxesGAYEg6IYGZeCiKkhiahClK1uTnM9NOXh4z7VAUJTE0CVOUjCgsLMTZs2cRl5rKSHuxqakIDw9HVlYWI+1RFMU8OjGLoljC5/Nx//59nD9/HufPn0dsbCx69uyJnzU1MfjyZaiUlorcdoWGBv4aMgQbVFTw999/Q09PD/3796+6de3aFSoq9BycothGkzBFSVFGRgYuXLiA8+fP4+LFi9DX18eIESMwfPhwDBw4EM2aNWNkdjRfQwMqGRlAq1bg8/lISkrCjRs3qm5v376Fra1tVVLu06cPtLS0GHylFEU1Bk3CFCVBhYWFuHLlSlVvNzs7G8OGDcPw4cMxfPhwtG3btvYnurgAkZH1l6qsA5/DwRl1dZyYMgXLly+HiYnJJ4/JysrCzZs3q5JyQkICLC0ta/SWjYyMhD42RVHCoUmYohjE5/Nx7969qqQbFxeHXr16VfV2P//8c6iqqjbckJgVswpOncKa8+exfft2zJo1Cz4+PtDT06vzKTweD7GxsVVJ+ebNm9DV1a2RlC0tLekQNkUxjCZhihLTy5cvawwxGxgY1Bhi1tbWFq1hYWpHV9LSqrGJQ0ZGBlasWIHIyEj4+Phg7ty50NTUbLAZPp+P5OTkGkPYb968Qb9+/WoMYTdt2lS01yYuuq0jpSBoEqYoIX348KHGEPObN28wbNiwqsRb2/CvyBjaRSkpKQnLli3DnTt3sHLlSkyZMqVxPfJqXr9+XWMIOz4+Hl27dq3RW27Tpo2wr1A4dFtHSsHQJExRDaioqKgxxHznzh307t0bw4cPx4gRI/D5559Ldpg2Lk6QeKKiBMm2ek3pysQzZowg8TSwacPNmzfh4+ODvLw8+Pn5wcHBARwOR6SweDwe4uLiagxhN2/e/JMhbGGTfZ3oto6UAqJJmKJqkZ6eXjXE/Oeff6J169Y1hphZGYbNyREMwSYkCApx6OkB1tbAtGlCDcESQnD69Gn4+vpCT08P/v7++OKLL8QOj8/n4/HjxzWGsLOzs2sMYfft21e0/zsGhuYpShbRJExREAwx//XXX1W93bdv31bNYGZ8iFlGVFRUYN++ffjf//6Hnj17Ys2aNbCwsGD0GNnZ2TWGsB88eAALC4savWVjY+P6G6HbOlIKjCZhSilVVFTg7t27VUn37t276NOnT1Vvt3v37kozE5jH4yEwMBD+/v4YP358ncuamFBcXPzJELa2tnaNpGxlZVVzCFuM5VrgcABnZyA8nLkXQVEMokmYUhovXryoMcRsZGRUlXQHDBjA3kxfGZGXlwd/f/9GL2tiAiHkkyHsrKysqiHsQV27wt7NDZySEtEPQrd1pGQYTcKUwnr//n2NIea8vLwaQ8wNDoMqKVGXNTElJyenagjb7MgRzHjxAlxxGuRygRUrgMWLmQqRohhDkzClMCoqKnDnzp2qpHvv3j307du3ahZzt27dlGaImQlMLGsSm5sbcOCA+O1MmQLs3St+OxTFMJqEKbn24sWLqqT7559/wtjYuCrpDhgwgNZDZgCTy5qE5ugInD4tfjsODsCpU+K3Q1EMo0mYkisFBQVVQ8wXLlzAu3fvahTKkHixCCUlqWVNDaI9YUrBqbEdAEXVp6KiAnFxcVW93fv376Nv374YMWIEDh8+DBsbGzrELAUcDgeOjo4YM2YM9u3bB1dXV4kta6rBxgYkPBwcMXaUApcrWE9NUTKI9oQpmfP8+fOqpHvp0iWYmJhUDTHb29vTIWYZII1lTampqdixZg2W794NcaaFVairg//8OdTpKAklg2gXgmJdQUEBTpw4AS8vL5ibm6Nv3764evUqxo0bh8TERMTHx2P9+vUYOXIkTcAygsvlYtGiRUhJSYG+vj66deuGpUuXIi8vT6x2CSG4fv06XFxcYGtrCxVDQ5BRowTrfUXA53BwQ0cH5l98gS1btqCwsFCs+CiKabQnTEldeXl5jSHmBw8ewNbWtqq3a21tTYeY5Yy4y5rKy8tx/PhxrF+/Hm/fvsXChQsxbdo0wdptBipmxfD58Pf3x7Vr1+Dl5YW5c+eiZcuWwrdHUUwjFCUFz549IyEhIWTChAlET0+PWFtbE29vbxIdHU2KiorYDo9iyKNHj4iTkxMxNTUlu3fvJuXl5fU+vqCggGzYsIGYmZmR/v37k+PHj9f+nKAgQrS0CBHUzWrcTUtL8LxqkpOTibu7O9HT0yPz588nz58/Z/LlU5TQaE9Y0bG072p+fj4uX75cNYv5/fv3VT3dYcOGwcjISGLHptjX0LKmly9fYsuWLdi1axeGDRuGH374AX379q2/UQZ3UXr16hU2bdqEnTt3YuzYsViyZAmsrKxEeakUJR62zwIoCYmJIcTZmRBNTcGteg+ByxXc5+wseBwDysrKyM2bN8ny5ctJ//79iba2Nhk+fDhZt24defDgAeHz+Ywch5IffD6fnDx5klhaWhI7Ozty48YNEhcXRyZNmkT09PTIggULSFpamnCNxsYS4uIieP9yubW/r11cBI9rhLy8PLJmzRpiaGhIHBwcyLVr14R/oRQlBtoTVkRS2nf12bNnVdd1L1++jLZt22LEiBEYMWIE7OzswOWKVWyQUhBlZWVYtGgRQkNDoaKiAi8vL/z000/Q0dERvVGGtnWsxOPx8McffyAgIACtW7eGj48PHBwc6NwESuJoElY0Etx3NT8/H5cuXaoaYi4sLKwxxGxoaChm8JQiKSoqwt69e7Fx40Zoa2tj3rx5eP36NQICAiS+W5OoKioqEB4eDn9/fxQXF2PJkiWYNGkSNDQ02A6NUlA0CSsShvddLS8vR0xMTFXSjY+PxxdffFHV27WyspJe+UJKbrx+/RqBgYEICQlBv3794O3tjQEDBlS9V9jYrUlYhBBcvHgR/v7+SElJwQ8//ICZM2dCW1ub7dAoRcPiUDjFNGdnQjgc4WaQVt44HEJcXEhqaioJCgoizs7ORFdXl3Tr1o0sXryYXLhwgfB4PLZfISXDEhMTyYwZM4iuri7x8PAgycnJ9T7+5cuXZObMmURfX5+sW7dOZt9fsbGxZOLEiURfX5/8/PPPJDs7m+2QKAVCe8KKIjsbMDMDxCjvV8zhoFerVug5alTVEHPr1q0ZDJJSNOTfHuP69etx//59eHl5wdPTE/r6+o1uQyZ2a2qEJ0+eICAgAEeOHIGbmxu8vb3Rrl07tsOi5B3LJwEUU/z9P50FLeStokkTwl+7lu1XQsmB4uJismfPHmJjY0MsLS3Jzp07xe7J3rhxg9jZ2RFLS0ty8uRJmZ1R/+rVK+Lj40NatGhBJk+eTB48eMB2SJQco1P/FEV8vFi9YABQKSkBJyGBoYAoRZSbm4s1a9agffv2OHDgAPz9/ZGQkIAZM2YIVSGrNl988QWuXr0KPz8/+Pr6YsCAAbh58yZDkTPHyMgIv/32G549ewYbGxuMGjUKY8aMwZUrV0DowCIlJJqEFUV+PjPtiFn7l1JMqampmDt3Ljp27IiUlBScO3cO58+fx6hRoxidnFe5W9ODBw/g7u4OV1dXODs7IykpibFjMEVHRwdLlizBs2fP4OzsjFmzZuGLL75AZGQk+Hw+2+FRcoImYUUhzprL6mRslirFHvLvZgrOzs6wtbWFjo4OHj58iD179sDGxkaix1ZVVcW0adPw+PFj9O/fHwMGDMDMmTORkZEh0eOKQlNTE7NmzUJSUhK8vb2xevVqWFpaYteuXSgtLWU7PErG0SSsKGxsADGHA+m+qxQgWJp2+PBh9O3bF9OmTcOwYcPw/PlzrF69Gm2kvB2gpHZrkgRVVVV8+eWXiImJQWBgIA4fPowOHTpg/fr1eP/+PdvhUTKKzo5WFAzMjoamJpCeLtGa0pTsKigowM6dO7F582aYmprC29sbjo6OMjVTWdzdmqTt7t27WLt2LS5evAgPDw/Mnz8fBgYGbIdFyRDaE1YUBgbA6NEi77sKDgcYM4YmYCWUnp6ORYsWoX379rh9+zaOHDmCa9euwcnJSaYSMACYmJhg+/btuHr1Km7cuIHOnTtjz549qKioYDu0WvXo0QNhYWG4ffs23r59iy5dumDOnDl49uwZ26FRMoImYQVCli5Fqagfmlwu4OvLbECUTIuLi8M333yD7t27g8/n486dOwgLC0OfPn3YDq1BFhYWiIiIQFhYGHbu3Ilu3brh1KlTMjs7uWPHjggODkZSUhL09PTQp08fTJo0Cffv32c7NIplNAkrCEIIFh48iABDQxBhN06orB1drWQlpZj4fD5OnjyJgQMHwsXFBT179kRaWho2bNggl4Un5GVZU6XWrVtj9erVePbsGXr27AkHBweMHDkSly9fltkTCErCWFyjTDGkvLyczJo1i9ja2pK8vLz/NkBvqIQlh1PrxueU4iksLCRBQUHE3Nyc9OzZkxw8eJCUlpayHRajysvLye7du4mpqSlxcnIijx49YjukBhUXF5OdO3eSzz77jPTu3ZscO3aMlJeXsx0WJUU0Ccu5srIyMnnyZDJo0CDy/v37/37A8L6rlHzKzMwkP/30E2nVqhUZN24cuXLlisxWomJKUVERWbduHdHX1yfu7u7k5cuXbIfUoIqKCnL8+HHSp08f0rlzZ7J9+3ZSXFzMdliUFNDhaDlWWloKV1dXvH37FlFRUTV3eOnVCwgPF8x2XrECmDIFxMEBYerqKFyyRHB/eDgdglZQiYmJmDFjBiwsLPDmzRtcv34dJ06cqLGbkaKSp2VNlVRUVODs7Ixbt24hNDQU4eHh6NChA9atW4eCggK2w6MkiCZhOcXj8eDs7Aw+n4/IyEhw67oO3KoVsHgxsHcvOKdOYWvv3ogbPJjOglZAhJCqKlbDhw9Hhw4d8OTJEwQHB6Nz585shyd1enp6+O233/DgwQO8ffsWnTt3RkBAAIrFLO8qSRwOB4MGDcLZs2cRFRWF+/fvo0OHDvD19UVWVhbb4VESQJOwHPrw4QPGjh0LXV1dHD58GE2aNGn0cy0tLfHw4UMJRkdJW0lJCfbs2YNu3brB29sbX3/9NZ4/f46ffvpJqN2MFJW8LWuq1K1bNxw4cACxsbF4//49unbtCg8PD6SmprIdGsUgmoTlTH5+PkaOHImOHTti7969UFdXF+r5VlZWNAkriLdv32L16tVo3749Dh06hHXr1iE+Ph7Tp08X6sRMWcjbsqZK7du3x7Zt25CcnIxWrVrB1tYWX331Fe7cucN2aBQDaBKWI2/fvsXQoUPRs2dPhIaGilRIwdLSEomJiRKIjpKWJ0+ewMvLC506dUJqaiqio6MRHR2NkSNHKvz1XiYwsqwpOxtYuxZwcwMcHQVf164FcnIkEzQAAwMDrFq1CmlpabC1tYWTkxOGDx+OixcvyvyJBFUPlieGUY2UmZlJrKysyNKlS8Wa3ZqZmUlatmyp8DNkFQ2fzydXr14l48ePJ/r6+mTZsmXk1atXbIcl94Re1hQTQ4izs2B1wcf7d1euOnB2FjxOwkpKSsju3buJhYUF6dmzJzly5Ahd3iSHaBKWA+np6aRz585k1apVYidPPp9PWrRoQbKyshiKjpKksrIycujQIdKrVy/SqVMnEhgYSD58+MB2WAqnUcuaZHT9fUVFBYmMjCS2trakU6dOJCQkhPB4PKkcmxIfTcIy7unTp6Rdu3Zkw4YNjLU5YMAAcvHiRcbao5iXn59P1q9fT9q2bUvs7e1JZGQk7eVIQW5uLvHx8SEtWrQgPj4+JDc3V/CDygRcX/L9+CblQjiVoyVjx44lhoaGxM/Pj7x7905qx6dEQ68Jy7Dk5GQMHDgQPj4+WLhwIWPt0hnSsis9PR3e3t5o3749YmJicOzYMVy9ehXjx4+Xuc0UFFFty5r2f/89yKJFQFGRcI0VFQGLFgFxcZIJ9iMcDgf29vY4ffo0zp8/j4cPH6JDhw7w8fFBZmamVGKghEeTsIyKj4/HkCFDsHr1anh4eDDaNk3CsicuLg6TJk3C559/DkCwBV5YWBh69+7NcmTKqfqypk5Hj4IvbAKuxOMBfn7MBtcI1tbW2LdvH+7evYvi4mJYWlpi1qxZSElJkXosVP1oEpZBMTExGD58ODZv3oypU6cy3j5dpiQbKioqqqpYubi4oFevXnj27BnWr18PMzMztsOjAFi0bIl+eXkQeQyCECAqSqKzputjZmaGzZs3IyUlBcbGxrCzs8OXX36J2NhYVuKhPkWTsIy5du0aHBwcsHPnTkycOFEix6hcpkTosgZWFBUVISgoCF26dMGvv/6KOXPm4OnTp/D29oaOjg7b4VHV7dkjfhscDjPtiEFfXx/Lly9HWloa7O3t8eWXX2LIkCGIjo6mnwMso0lYhly4cAETJkzAwYMH4eDgILHj6Ovro0mTJnj16pXEjkF9KisrCz/99BPMzMxw/vx57Nq1CzExMXB1dRW66AolJfHxgLhlLnk8ICGBmXjE1LRpU3z//fdITU3F9OnT4e3tjR49eiAsLAzl5eVsh6eUaBKWEadOncLkyZNx/PhxDBs2TOLHo9eFpSchIQHTp0+HhYUFcnNzcePGDURGRsLe3p4W15B1+fnMtCNjm0eoq6tjypQpiI+Px6pVqxAYGIjPPvsMwcHB4PF4bIenVGgSlgFHjhzBzJkzcebMGdjZ2UnlmFZWVrRy1scYrIJE/t1MYeTIkRgxYkRVdaugoCCl3ExBbjF1eUBPj5l2GKaiogIHBwdcu3YNe/fuxdmzZ9G+fXusXr1atF2nWKgkJvdYXiKl9Pbs2UOMjIzIgwcPpHrckJAQMmPGDKkeU2YxWAWpuLiY7Nq1i1hZWRErKyuye/duui+sPPP3//Q9IeSNz+USsnYt26+k0RITE8m3335L9PT0iLe3N8nIyGj4STJUSUze0CTMoqCgIGJiYkKSkpKkfuxr166Rvn37Sv24MoehKkhv3rwhq1atIoaGhmTEiBEkOjqalgZVBK9fi52EeQDxX7So9ipcMuzFixdkwYIFRE9Pj8yYMaPuzykZrSQmL2gSZklAQABp164defr0KSvHz83NJdra2sqdKBiogpSSkkI8PT2Jrq4umT59OklISGDxBVES4exM+A0lmHoSz7uhQ4mXlxfR09Mj48aNI1FRUXJV/ezNmzdkxYoVxMDAgDg5OZG///77vx/KQSUxWUeTsJTx+XyycuVK0rlzZ5Kens5qLG3atCHPnz9nNQbWxMQI/+FRObyopUXuhIaScePGEX19ffLjjz+SzMxMtl8RJSGphw6RIlGTsJYWIbGxhBBC3r9/T7Zv30569OhB2rVrR9asWSNXNdwLCwvJ1q1biZmZGRk4cCC5sWkT4Yv4N1T9/0XZ0SQsRXw+n/j4+BArKyuZ+NAePnw4OXPmDNthsMPZueHhszpu5QA517QpCQoKIoWFhWy/EkqCwsPDib6+Prk1bRqjPb7Y2Fji7u5OdHV1yVdffUUuXbokN6NSpaWlZP/+/eRCs2akXNRheg6HEBcXtl+KTOAQQgjbk8OUAZ/Px4IFC3Dz5k1ER0ejZcuWbIeEH374AUZGRli8eDHboUhXdjZgZibW+k+iqQlOejrQqhWDgVGygs/n45dffsHevXtx/Phx9OzZEwgOFtSC5vEEqaQuHA7A5QIBAYCnZ73HeffuHfbv34+QkBCUlZXBw8MD3377LVq0aMHwK2JYdjaImRk44qyh1tQE6N8QXaIkDRUVFZg1axbu3LmDP//8UyYSMPBf5Sylw0D1Io4MVEGiJCM/Px/jx4/H1atXERsbK0jAgCChXrkCODsLEgiXW/OJXK7gfmdnweMaSMAAoKuri7lz5yIhIQE7d+7E3bt30aFDB0ydOhU3b96EzPaR9uyB2Cvc6d8QAECN7QAUXVlZGb799lu8fv0a0dHR0NbWZjukKpaWlggODmY7DOlTsCpIFHOSk5Ph5OSEYcOGYePGjZ9WMuvVCwgPF6x73bNH8B7IyxOsA7a2BqZNE6lnx+FwYGdnBzs7O7x58wZ//PEHvv32W3C5XHh4eMDNzQ3Nmzdn5DUygv4NMYYOR0tQSUkJXF1dUVpaimPHjoH78ZkzywoKCmBkZIT3799DRUVxB0UKCgqQkZGBf/75BxkZGej/22/ozMRuMg4OwKlT4rdDyYRTp07B3d0dfn5+cHd3Zzsc8Pl8XL58GSEhIbh48SImTpyI2bNn/9czZ5OjI3D6tPjt0L8h2hOWlKKiIkyYMAFNmzZFREQENDQ02A7pE82bN4e+vj7S0tLQsWNHtsMRGiEEb9++RUZGRtWtMtFW/zefz4eJiUnVrTtTdZpltAoSJRw+n4/Vq1cjNDQUJ0+eRL9+/dgOCYCgmtXQoUMxdOhQZGVlYdeuXZgwYQJatWoFDw8PuLq6omnTpuwEp+CVxKSJJmEJeP/+PRwdHWFqaordu3dDTU12/5sra0jLWhKuqKhAVlbWJ4m1+vf//PMPmjZtWpVcjY2NYWJiAnt7+6p/m5iYoHnz5jVrNK9dC/zyi3jDaVyuYPiRkmvv37/HtGnTkJmZidjYWBgZGbEdUq0MDQ2xbNky+Pj4IDo6GiEhIViyZAm++eYbzJ49G1ZWVtINyMZGMCxP/4bERoejGfbu3TuMHj0a1tbWCAkJkflh3sWLF6NFixbw9fWV2jFLSkrwzz//1NprrbxlZ2dDX1+/RjKtnmhNTEzQpk0baGlpCR8AA7Oj6cxO+ZeamgonJyfY2tpi27ZtaNKkCdshCSU9PR07duzAjh070LFjR3h4eGDChAnQ1NSU/MHp3xBjaBJujOxswSSM+HjBrio6OoIzwenTa7yBcnJyMGLECAwcOBAbN26Uix1y/vjjD5w/fx4HDhxgpL3379/XmVwr/52fnw8jI6NaE2vl90ZGRpLd3s/FBYiMrH+pSV04HMEM2PBw5uOipCI6OhpTp07F8uXL4eHhIRd/q3UpKyvDqVOnEBoainv37uHbb7/Fd999B3Nzc8kemP4NMYIm4frExgJ+fsDZs4Lvq5/1cbmCN9/o0YCvLzJNTDBs2DA4Oztj1apVcvNHHRcXh5kzZ+L+/fv1Po4Qgtzc3HqHhzMyMlBeXl5rcq3+71atWrE/QhAbCwwaBBQVCf9cLS3BEpRevRgPi5IsQgjWrVuHTZs24fDhw7C3t2c7JEalpqZi+/bt2L17N2xsbODh4YHx48dL5oRWjL+hMg0NqN+4Qf+GQJNw3YRYmM/X1MRybW1oLliAZcuWSS9GBhQWFkJfXx8pKSlV12DrSrRcLrfe4WFjY2Po6urKzQlI1e9YmA8RLa1GFWGgZE9RURHc3d3x5MkTREREwNTUlO2QJKakpATHjx9HSEgIUlJS4O7ujlmzZsHMzIzZA4nwN8TX1MQv2trgeHpixYoV8vN5ISE0CddGhDdWmbo61DdvlrkP59LSUrx69are5Pry5Uvo6+vDzMyszuFhY2Nj9mZiSlIjT7YqAKhwueCsXy9zv2OqYc+fP4ezszOsra0RGhoqc8sFJenRo0cIDQ3F/v37YWtrCw8PD4wePRqqqqrMHODfvyF+UVH91Z+qVRLLnjABjo6OsLCwwO+//y6Tq0ekhSbhj8nRMGVhYWGDw8N5eXlV11/rGh728vLCjBkz4OLiIpW4ZU5cnOCyQ1SU4IOCx/vvZ/9edogzMMDfgwZh3h9/sBcnJZJLly7hm2++ga+vL+bPn6+0Pa+ioiIcPnwYoaGhePXqFWbNmgV3d3e0adNG7LbfXbyIq2PGwFFFBRwVlVr/hjBmDODrW/X5WFhYiEmTJoHH4yE8PFy2ipFIEU3CH5OByQaEEOTl5dU7e/iff/5BSUlJg8PDBgYGDZ7x+vr6QktLCz///LNYccu9eqogZZaXw9raGrdu3UKnTp3YjpRqBEIItmzZAj8/Pxw4cABDhw5lOySZce/ePYSGhuLw4cMYMmQIPDw8MHToUJHnavj7+yM5ORm7164VqpJYeXk55s+fjxs3biAqKgrGxsbivTA5RJNwdVKYds/n85GdnV1vcs3IyICGhka9ydXExAR6enqMnNXv378fp0+fRlhYmNhtKTJ/f3/cuHEDJ0+eZDsUqgE8Hg8eHh548OABIiIi0L59e7ZDkkkFBQU4ePAgQkJC8OHDB8yePRvTpk1DKyGWDZWXl6NDhw6IjIxEjx49hI6BEAJ/f38EBwfjzJkz0l/zzDKahKtjoIgDX1MTL2bMQOzAgbUm2szMTOjp6dU7PGxsbCzVGtP379+Hm5ubcm7mIISSkhJYWloiMDAQI0eOZDscqg4vX76Ei4sLOnbsiJ07dyrmXAaGEULVXF+aAAAgAElEQVRw+/ZthIaGIiIiAmPHjoWHhwfs7OwaPNEPDw/Hpk2bcO3aNbFiOHDgABYuXIjDhw9j8ODBYrUlT2gSrs7NDWBgvWyUvj52DxpUa3Jt06aNzBUFKC4uhp6eHgoKCiS7NlcBnDx5EkuXLsWDBw/o/5UMun79Or766issWLAAixcvVtrrv+LIy8vD3r17ERISAg6HAw8PD0ydOhW6urq1Pn7gwIHw8vLCV199JfaxL126BFdXV2zatAnffPON2O3JBclvWSxHHBxE26D645uDA9uvRGjm5ubk4cOHbIch8/h8PhkxYgTZuHEj26FQ1fD5fBIcHEwMDAzI2bNn2Q5HIfD5fPLXX38RV1dXoqOjQ6ZPn05u375N+Hx+1WPu3btHjI2NSWlpKWPHTUhIIKampsTPz6/GsRSVbNdUlDYlLkpuZWVFh6MbgcPhYNOmTVi9ejVycnLYDoeC4DLB7NmzsXXrVty4cQOjRo1iOySFwOFwMHDgQBw6dAgpKSn47LPP4Orqip49e+L333/H+/fvsXXrVsyZM4fRUSErKyv8/fffOHToELy8vFBRUcFY27KIJuHqbGwEE6vEIadFySs3cqAaZmFhgcmTJ+Onn35iOxSll5mZicGDByMnJ4fOXJcgAwMD+Pj4IDU1FX5+fjh37hzatm1btfaYacbGxrh69SpSUlLg4uKCIlGWjMoJmoSrmzZN/DYIYaYdKaNJWDjLly/HiRMncO/ePbZDUVq3bt1C7969MXr0aISHh6NZs2Zsh6TwVFRUMHLkSBw/fhyzZ8+GpaUlpk6dCltbW/zxxx/gVV8fLCYdHR1ERUVBV1cXgwcPRnZ2NmNtyxKahKszMBDUghZ1MgeHI1iQLoe7glhZWdEkLARdXV2sXLkS8+fPB6FzG6Vu165dGDduHIKCgvDzzz+zX4tcyZSXl+PAgQPYuXMn0tLS4Ovri8OHD8PU1BQLFy5EcnIyI8fR0NDAnj17MGLECHzxxRd48uQJI+3KFLYvSsucmBhCtLREm5ClpUVIbCzbr0AkJSUlRFNTkxQXF7MditwoLy8n3bt3J2FhYWyHojRKS0vJ3LlzSefOnUlSUhLb4Sito0ePEnt7+0/uT0tLI8uWLSOtW7cmgwYNImFhYaSkpISRY4aGhhJDQ0Py999/M9KerKBJuDZBQcInYi0twfPkmIWFBXnw4AHbYciVq1evElNTU1JYWMh2KArv9evXZMCAAWTs2LHk3bt3bIej1Ozt7cnRo0fr/HlJSQk5cuQIGTJkCDEwMCA+Pj7k6dOnYh/3zJkzRF9fn0RERIjdlqygYzi18fQU7JSjpdXw0DSHozA769DrwsKzt7fHF198AX9/f7ZDUWh37txB7969YW9vj5MnT0KHqZUMlNDu3buHtLQ0ODk51fkYDQ0NTJw4EX/++SeuXr2KsrIy9O3bF6NGjUJkZCTKy8tFOvaYMWNw9uxZzJkzB9u2bRP1JcgWts8CZFpsLCEuLqRcXZ3wVFRq9ny5XEI0NQlxcZHbIeiPLV++nCxbtoztMOTOixcvSIsWLcjz58/ZDkUh7d+/n+jr69fb86KkZ/r06WTNmjVCP4/H45F9+/aR/v37E2NjY/LLL7+Qly9fihTD06dPSefOncnixYtJRUWFSG3ICloxqxG2/Pwz2l+5Asd27RpVlFxeHTt2DPv370dkZCTbocidFStW4OHDhzhy5AjboSiM8vJy+Pj4IDIyEpGRkbCWw6V/iiYnJwedO3fGkydPoK+vL3I7CQkJCA0NxcGDBzFgwAB4eHhgxIgRQk2we/v2LcaPHw9TU1Ps2bNH5ioRNhZNwo0wdepUDB48GNOnT2c7FIlKSkrCuHHjFHMGooQVFRWha9eu2LNnDwYNGsR2OHLv7du3cHV1BYfDQVhYGFq0aMF2SBSANWvW4OnTp9i5cycj7X348AFhYWEIDg5Gbm4uvvvuO8yYMQOtW7du1PN5PB6mTJmCnJwcREZGQk8OCyXRa8KNkJiYCEtLS7bDkLhOnTohIyNDoRfGS4qWlhbWrVuH77//XuEr/EhafHw8evfujc8//xxRUVE0AcuIsrIyBAUFYd68eYy1qa2tjZkzZ+LOnTs4evQonj59ii5duuDrr7/G5cuXG1z+x+VycfjwYfTo0QP9+/fHixcvGItNWmgSbkBFRQWSk5PRtWtXtkOROHV1dZibmzO2xk/ZfPnll9DT08P27dvZDkVuHT16FEOHDsWvv/6KtWvXQk1Nje2QqH9FRESgY8eO6N69u0Ta79WrF3bs2IHnz59jwIABmDdvHrp06YKNGzciNze3zuepqqpi48aNmDVrFvr37y9/BXRYvSItB1JSUki7du3YDkNqXF1dyd69e9kOQ27dv3+fGBgYkNzcXLZDkSvl5eXE19eXmJmZkTt37rAdDlWL/v37k2PHjknteHw+n1y/fp24ubkRHR0dMnXqVHLz5s16N3U4cuQI0dfXJ+fOnav9Aa9fE+LvT8jkyYKNdiZPFnyfnS2hV9EwmoQbcPz4ceIgh7siierXX38lPj4+bIch1zw8PMj8+fPZDkNu5OXlkdGjR5NBgwaRbBY/DKm63blzh5iampKysjJWjp+Tk0MCAgKIubk5sba2JoGBgSQ/P7/Wx167do0YGBiQXbt2/XdnTAwhzs6CFS2amrWvdHF2FjxOyuhwdAMePnyoFNeDK1laWtLdlMS0atUqHDx4kK65boSkpCT06dMH5ubmOH/+PFop0GoDRVK5WxJblwf09fXh7e2N5ORkbNy4EX/99RfMzMzw3Xff4e7duzUea2dnhytXrmDlypVYvnw5SHAwMGgQEBkJFBcLbtXxeIL7IiMFjwsOltrrAkCHoxvy9ddfk3379rEdhtQo2/C7pGzevJkMGzZMKfZDFVVkZCRp1aoV2b17N9uhUPV4/fo10dXVJTk5OWyHUkNmZiZZvXo1MTMzI7179yY7d+4kHz58qPlzU1NSrKoq09UP6RKlBlhbW2Pv3r34/PPP2Q5FKioqKtCsWTNkZ2dDW1ub7XDkVllZGbp37441a9Zg/PjxbIcjU/h8PlatWoUdO3YgPDwcffr0YTskqh6rV69GWloaduzYwXYotaqoqEB0dDRCQkJw48YNfPPNN5g9ezaseDyQgQPBEWVnJy0t4MoVoFcv5gP+CE3C9SgrK0Pz5s2Rm5sLLpfLdjhS06NHD4SEhNAPRzFduHABHh4eePjwITTF3adaQRQUFGDq1KnIyclBeHg4DA0N2Q6JqkdZWRnatWuHqKgodOvWje1wGpSeno4dO3Zgx44dOFRSAvu8PKiIkuI4HMDZGQgPZz7Ij9BrwvV48uQJTE1NlSoBA7SGNFOGDx8Oa2trbNy4ke1QZEJKSgr69esHQ0NDXL58mSZgOXD8+HGYm5vLRQIGgLZt22LlypV4ERsLu/fvRUvAgGBgOioKyMlhNsBa0CRcj8TERFhZWbEdhtTRJMyc9evXY/369Xj16hXbobAqKioKdnZ2+P777xESEgINDQ22Q6IaYcuWLZg/fz7bYQhN/cABqKqqitcIhwPs2cNIPPWhSbgeyjYzupKVlRWdIc2Qjh074rvvvsPSpUvZDoUVhBD89ttvmDVrFiIiIjB79my2Q6IaKS4uDhkZGRg3bhzboQgvPv7TWdDC4vGAhARm4qkHLUdTj8TERHz11VdshyF1tCfMLF9fX3Tp0gW3bt1Cv3792A5HagoLCzF9+nS8ePECMTExMDY2ZjskSghbt26Fl5eXfFYty89npp28PGbaqQftCddDWYejzczMkJeXh3ym3shKrlmzZvjtt98wf/588Pl8tsORimfPnsHW1hZNmzbFlStXaAKWM9nZ2Th58iTc3d3ZDkU0TO03LYUNIWgSrkNxcTHS09Nhbm7OdihSp/LmDdbo6aH0668BR0fAzQ1Yu1YqkxQU1eTJk6Gqqoq9e/eyHYrEXbx4Eba2tpg1axZ27dpFZ4bLod9//x1ffvklWrZsyXYoorGxAcR933G5gi1rJU1qK5LlzL1794ilpSXbYUhXtdJuJR8vcGe5tJsiuH37NjEyMqqz3J684/P5ZP369cTQ0JBcvnyZ7XAoEZWWlpI2bdqQBw8esB2K6F6//rQ8pbA3TU2p1JSmPeE6KN2krI9Ku2l8vB0f26XdFECfPn0wcuRI/Prrr2yHwjgej4epU6di//79uHXrFt1TWY6Fh4ejc+fOsLGxYTsU0RkYAKNHC2Y4i4LDAcaMAaRQRpUm4Too1fXg4GBg0SKgqEhwDlgfQgSPW7SIJmIR+Pn5YdeuXXjy5AnbodQvO1twCcLNrcFLEunp6bCzs0NFRQWuX78OMzMzFgKmmCKvy5I+4esrGFIWBZcreL40SLyvLaccHR1JeHg422FIXkyMoFaqKMM1WlqExMay/Qrkjr+/v+zuzCXkbjNXrlwhhoaGJCAggNbJVgAxMTHEzMyMtd2SGBcUJPznm5RrR9MkXIf27duTx48fsx2G5Dk7E8LhiJaEORxCXFzYfgVyp7i4mHTq1ImcPXuW7VBqqvzAauj9wOEQvpYWufz118TAwIBER0ezHTnFkClTppC1a9eyHQazhHhfSzsBE0I3cKhVYWEhWrVqhffv34tfdUWWZWcDZmbiLWrX1ATS06Vy7USRnD59GosWLUJCQgLU1dXZDqfmJYlG4nE4eL98OQz+9z8JBkZJy+vXr9GlSxc8ffoULVq0YDscZsXFAX5+4J8+jZKyMnCrpz0uV5CGx4wRDEFLYdOG6ug14Vo8evQIn332mWInYICZkmxSKu2maMaOHYt27dph27ZtbIcCxMYKnYABgEsIDPz9BR9wlNz7/fffMXHiRMVLwIAgsYaHIyokBGFdugBTpgAODoKvK1YIOhLh4VJPwACtmFWrxMRE5ZgZzVBpt7K7d0FKS6GmpgYVFXpe1xgcDgebNm2Cvb09Jk+eDAMDA/aC8fMTzH4XBY8neL4UdpuhJKe0tBTBwcGIjo5mOxSJupeRgaLx4wXvWRlBk3AtHj58qBwzoxmqiHX+yBE4h4ejrKwMKioqUFNTg7q6uthfmWiD6RjU1NTAEXXZw0e6dOmCKVOm4KeffsLvv//OSJtCy84Gzp5teFZ8XarvNkMvScit8PBwdOnSBdbSKE7BoocPH8LR0ZHtMGqgSbgWiYmJ8PLyYjsMyWOotNvYyZNRuncvCCHg8/koKytDeXm51L5++PChwccxdazy8nKoqqoylugJIThz5gyys7PRunVrqZ+ENAsJgTYAsU4rKi9JLF7MyPuJkr4tW7bAx8eH7TAkLjExUeY2U6FJuBZK0xO2sREMI4ozJF2ttBuHw4GqqqpCX0snhKCiooLRE4nmzZvj2rVrGDVqVFWi//gEoqioSOT26/vZ5txcTCwpEe8/RUq7zVCSERMTg8zMTJnrITKttLQUT58+RZcuXdgOpQaahD/y7t075OXlKUfBgWnTgF9+Ea8NQgTtKAkOh1M1LM2Ur7/+Gr1794auri5cXV0Za7dRHB2B06fFb0cKu81QkrF161bMnTtXoU+eAeDJkydo27atzNUyp7NoPvLo0SN07dpVOSYYyVFpN0WmqqqKLVu2YMmSJSgsLJTuweVotxmKeVlZWTh9+rT87pYkBFktRawEmUY4SlWuEpCf0m4Kzs7ODv3794e/v790DyxPu81QjAsNDcXXX38NPSU4iZLVz3aahD8iq2dLEtO7NxAQAGhpCfc8LS3B81hYV6eo1q5di8DAQDx//lx6B2XiUoKSXZJQFKWlpQgJCcHcuXPZDkUqZPWznSbhj8jq2ZJEeXpWJWJ+Q0PTHM5/CdjTUzrxKQlTU1MsWLAAi6U5y5heklBax44dQ9euXZXm805WP9tp2cqPGBoaIi4uDiYmJmyHInUkNhaXhg/HoKIiqKqp1SzgwHJpN2XB4/FgYWGB3bt3Y/DgwdI5aGysYHtKIStmARCckF25Qt8Pcqhfv37w9fXF+PHj2Q5F4oqLi6Gnp4f8/HxoaGiwHU4NdHZ0NTk5OSguLoaxsTHbobDiVnk5ZuvrI+XGDWDvXsGyk7w8waQba2vBkCPt8UgUl8tFQEAAFixYgDt37jA6C7tOlZckhC1dSS9JyK3bt2/j9evXcHBwYDsUqXj8+DE6duwocwkYoEm4hsprBkxVRJI327Ztg5eXF1Rat6aFF1g0YcIEBAYGYvv27fCU1pB/5XEWLRKMgNQzQFYBQIXLBYdekpBbyrIsqZIslyKm14SrUZoiHbXIyspCVFQUptEJNqzjcDjYvHkzli9fjtzcXOkd2NNTMLTs7CyYMf3xrHkuF9DUxIN27bDRyYkmYDmVmZmJM2fOYMaMGWyHIjWyOikLoD3hGmT5bEnStm/fjq+++koplirIAxsbG0yYMAHLly/Hli1bpHfgf3ebQU6OoBRlLZckTAjBmq5dMfbxY3z22WfSi41iRGhoKFxdXZXqbz0xMVFmOxh0YlY1AwYMwPLlyzFkyBC2Q5GqsrIytGvXDufOnVP4Au7y5O3bt7CwsMClS5dkboRm3bp1uHr1Kk6dOsV2KJQQSkpKYGZmhkuXLqFr165shyM1HTt2RFRUlEyeNNLh6H8RQpS2JxwREQFzc3OagGVMy5Yt8b///Q8LFiyArJ0rz58/H0lJSTh//jzboVBCOHr0KKysrJQqARcWFiIzMxMdO3ZkO5Ra0ST8r6ysLKiqqrK7rytLtm3bpjQL9uWNh4cHsrKycOLECbZDqaFJkyYICAjADz/8gPLycrbDoRppy5YtmD9/PtthSFVSUhI6d+4snZUGIqBJ+F+VvWBlmxn94MEDPHv2TCnWCsojNTU1bN68Gd7e3igWZ7crCRg/fjwMDAzY2wuZEsrt27fx5s0bjB07lu1QpEpWi3RUokn4X8o6MzowMBAeHh5QV1dnOxSqDkOHDkW3bt2wYcMGtkOpgcPhYNOmTVixYgXy6C5KMm/Lli1KtSypkizPjAZoEq4i62dLkpCXl4ejR49i1qxZbIdCNSAgIAAbNmzAP//8w3YoNdjY2MDJyQkrV65kOxSqHq9evUJUVJRSLUuqJOsdLJqE/6WMk7J2796NsWPHonXr1myHQjWgQ4cOmD17NpYuXcp2KJ9YtWoV9u3bh8ePH7MdClWH0NBQTJo0Cbq6umyHInWy/tlOlyhBMDNaR0cHz58/R4sWLdgORyr4fD7Mzc1x4MAB9OvXj+1wqEb48OEDunTpgqNHj8LW1pbtcGoICAjAlStX6JIlGaSsy5IAoKCgAG3atEFBQYHM7hEvm1FJWXp6OrS1tZUmAQPAuXPnoKenh759+7IdCtVI2tra+O233zB//nzw+Xy2w6lh3rx5dMmSjDpy5AhsbGyULgEDgqFoCwsLmU3AAE3CAGT/moEkVC5LUrbZ4PJu8uTJUFdXxx9//MF2KDVULllauHAhXbIkQwgh2Lx5M+bNm8d2KKyQ9UlZAE3CAGT/mgHTUlNTERcXB1dXV7ZDoYTE4XCwZcsW/PjjjygoKGA7nBrGjx8PQ0NDumRJhty6dQt5eXkYM2YM26GwQh4m3NIkDOXrCQcGBsLd3R2amppsh0KJoFevXhg1ahRWrVoluCM7G1i7FnBzAxwdBV/XrhXUf5YiDoeDjRs30iVLMkRZlyVVkoeeMJ2YBaBnz54IDAxUiglKHz58gJmZGe7evQszMzO2w6FElJWVhSlduuB4795odv264M7qxTy4XMF2hKNHA76+gj2DpWT27NnQ0tLCxo0bpXZMpZedLdhwIz4eyM8HdHSQ364dem7dirgXL5RyVjQAGBkZISYmBqampmyHUielT8IVFRVo3rw5MjMz0bx5c7bDkbjQ0FCcO3cOERERbIdCiSM4GGXffw/VsrL6h7M4HEFCluLev9nZ2ejatStu3LghkwXzFUpsLODnB5w9K/i+2olYmZoaQAjUx42T+omYLMjNzUX79u3x7t07mZ77ovTD0WlpadDX11eKBEwIoXWiFUFwMLBoEdQbSsCAoDdcVAQsWiR4nhQYGBhg6dKl8Pb2lsrxlFZwMDBoEBAZKUi+H5U1VS8vh3pFheDngwZJ7fcvKyqHomU5AQM0CSvV9eCrV6+ivLxc6bZqVCixsYKEWlQk3PMqE3FcnGTi+si8efOQnJyM6OhoqRxP6fx7IoaiIsGJVn1YOBGTBfIy4Vbpk7C8/KKYQJclKQA/P4DHE+25PJ7g+VLQpEkTrF+/nu6yJAlyciLGNnmYlAXQJCwXU9iZkJGRgT///BNTp05lOxRKVNnZgmt/ok7jIASIipLarOlx48bB0NAQoaGhUjme0pCTEzG2yctnu9InYWUZjg4NDcXkyZPRrFkztkOhRLVnj/htcDjMtNOoQwmWLK1cuZIuWWKKnJ2IsYUQIjejnLK5y7GUlJWV4cmTJ+jSpQvboUhUSUkJtm/fjr/++ovtUChxxMd/MvlGaDwermzbhpC7d6Gqqlp1U1NTq/F9bfeJ+pju3btj2rRpmD17dqPbEfb4KioqynGZhckTscWLxW9LRmVnZ4MQAkNDQ7ZDaZBSJ+HU1FSYmJhAS0uL7VAk6tixY7CxsVH4kw2Fl5/PSDPm+vpwdHRERUVFjVt5eXm935eWln5yX2Oep6KigrNnzyIvLw+ampq1PqYx7dR3HyEEKioqjJ1MMHkSwuTxbaKj0YaBEzEkJDDyXpJV8jIzGlDyJCwvwxXi2rp1K5YtW8Z2GJS4dHQYaaaNpSW++eYbRtpqrICAAPz11184ffq0RNonhAiVvJk+CWjMY0pLS8Vu55cHD9CGif8wBb88IC/XgwElT8LKcD04NjYWWVlZGDt2LNuhUOKysQHCw8UbkuZyAWtr5mJqpPnz5yM0NBTR0dEYOXIk4+1zOByoqalBTU0NTZo0Ybx9meHmBhw4IH47enrityHDHj58CBsbG7bDaBSlnpilDD3hwMBAzJkzR2lrxyqUadPEb4MQZtoRkoaGBgICAuiSJXHZ2ADi1nxn6URMmuSpg6XUSVieflGiyMnJwYkTJ+Du7s52KBQTDAxQOnQoRN5JmMMBxowBWrViMqpGo0uWGCDHJ2LSIk8zowFlS8LVdpupGDMGP6ekwOLUKYWdrr9z5044OzujZcuWbIdCMSAlJQXfJCSgXE3Eq0hcrqCGMEvokiUGGBgINuUQdcIRyydi0vDq1Ss0adIE+vr6bIfSOEQZxMQQ4uxMiKam4CY4FxTcuFzBfc7OgscpiLKyMtK2bVty584dtkOhGHDhwgViYGBAtm/fTkhQECFaWjXfxw3dtLQEz5MBs2fPJt9//z3bYcivmBjhf//V3wexsWy/Aok6d+4cGTJkCNthNJriJ+HKDywOp/43J4cjUx9U4oqIiCC2trZsh0ExIDAwkLRu3Zpcvnz5vzvl+H39+vVr0rJlS5KUlMR2KPJLzk/EJGn9+vVk3rx5bIfRaIqdhJX4jTp06FBy4MABtsOgxFBaWkrmzJlDLCwsSGpq6qcPiI0lxMVFMJLD5dY+wuPiIpM9n3Xr1pGxY8eyHYZ8k+MTMUmaPn06CQ0NZTuMRlPc/YRjYwXbdwlb5BwAtLSAK1eAXr0YD0sakpKSMHjwYKSnp0NDQ4PtcCgR5OXlYeLEidDQ0MChQ4egU98a4ZwcQQWkhATB+k89PcHs12nTZPbaX2lpKSwtLbFt2zaJLFlSGnFxglrQUVGC673Va0pzuYI0PGaMYC6AnH6eCatv377YsGED+vfvz3YojaK4SdjFRbCPpigvj8MBnJ0FazLl0Ny5c9GiRQusXLmS7VAoEaSkpMDR0RFjx47FunXrFHZ52YkTJ+Dr64v4+HioiTrZjBKodiKWlZSER5mZGPL99zJ9IiYJfD4fOjo6ePnyJXR1ddkOp1EUMwlnZwNmZuIVNdDUBNLT5e4NXFBQgHbt2iExMRFt2jBSW4eSoosXL2Ly5MlYvXo1Zs6cyXY4EkUIwbBhw+Di4gIvLy+2w1EYT548wYgRI5CWlsZ2KFL3/Plz2NnZISMjg+1QGk0xlyjJ2W4zTPrjjz8wfPhwmoDlUFBQENzc3HDkyBGFT8DAf0uWVqxYgdzcXLbDURgdOnTA69evUVhYyHYoUiePtR8UMwkztNuMvBU55/P52LZtG+bOnct2KJQQysrK4OXlhcDAQNy8eRMDBw5kOySpsbGxgYuLC710wiBVVVV07twZSUlJbIcidfJUpKOSYiZhhnabkbci53/++Sc0NTVhZ2fHdihUI+Xl5WH06NFIS0vDzZs30aFDB7ZDkrqVK1di//79SE5OZjsUhWFpaYlHjx6xHYbUVe6eJE8UMwkztNuMvBU5r+wFy8P2XZRgAla/fv1gY2ODU6dO1T8DWoEZGBjA19cXixYtYjsUhdG1a1c8fPiQ7TCkTp52T6qkmEmYgSLnfE1NuSpy/vz5c9y4cUPqW9RRorl48SLs7e2xePFibNiwQWFnQDfWvHnz8PjxY0RHR7MdikJQxp5wRUUFkpOT0bVrV7ZDEYpiJmEGipOXFhfD/fp1XL58GfIwgTw4OBjffvstmjZtynYoVAMCAwOVagJWY1TusrRw4UK6yxIDlLEn/OzZM7Ru3Rra2tpshyIUxUzCDBQ5V3V0RI8RIzBv3jxYWlpiy5YtePfuHbNxMoTH42HXrl3w9PRkOxSqHpUTsIKCgpRuAlZjjBs3Dm3atKG7LDGgQ4cOyMrKUqoZ0vJ4PRhQ1CQMCCrEcLkiPbVMTQ1qP/8MLy8vJCQkICQkBDdv3kT79u3x3Xff4d69ewwHK56wsDD06dMHnTp1YjsUqg50AlbDOBwONmzYQJcsMUBNTQ3m5uZKNdlNHpcnAYqchHv3BgICBCUohcDnchFgZISpW7aguLgYHA4HAwYMQFhYGJKSkmBmZobx48fD1tYW+/btQ7G4S6HERAjB1q1b6bIkGUC/UKYAACAASURBVEYnYDUeXbLEHGW7LiyPy5MARU7CAODp+V8ibmhomsMBtLSgsn49vk9KQmlpKQYPHoysrKyqhxgaGuLHH3/Es2fP4OvriwMHDqBt27ZYsmQJnj59KuEXU7tbt27h/fv3tP6ujKITsIS3atUqHDhwQKl6cZJgaWmpVNeFaU9YVnl6CjZjcHYWzJj+eIiayxXc7+wseJynJ7S0tBAWFoZRo0ahb9++uH//fo2nqKmpYdy4cTh37hxu3rwJQgj69euH0aNH49SpU6ioqJDay9u6dSu8vLygoqL4v0p5QydgiaZVq1ZYunQpvL292Q5FrinT5KyysjI8efIEXbp0YTsUoSlm7ei6iLDbzNGjRzFnzhyEhobCxcWlzqZ5PB6OHj2KoKAgZGZmYvbs2XB3d0fr1q0l81oAZGZmomvXrkhLS5ObYuXKoKysDAsWLMBff/2FU6dO0eu/IqjcZWnr1q0YNWoU2+HIpZSUFIwePZq1UTppSkpKwrhx4/DkyRO2QxGaciVhEd25cwdOTk7w8PDAsmXLGiyGcffuXQQHB+PYsWMYNWoUPD09YW9vz3gRjZUrV+LVq1cICQlhtF1KdEJtQUjV6+TJk1i6dCndZUlE5eXlaN68Od68eQMtIefGyJujR4/i4MGDiIiIYDsUodExzEbo2bMnbt++jRMnTsDNzQ286nt21qJHjx7Yvn070tLSYGtri++++w7W1tYICgpCQUEBIzGVlZUhNDSU7j4jQ+gELGY5OjqiTZs29CRTRMo0Q1pelycBNAk3Wps2bXDlyhVUVFR8MmGrLrq6upg/fz6SkpKwdetWXL58Ge3atYOnpyfi4+PFiiciIgLm5uawlqOqXoqscgLWkiVL6AQshlTusrRy5Uq6ZElEynJdWB7LVVaiSVgIXC4Xhw4dwtixY9GnT59GrxfmcDgYPHgwjh49isTERBgZGWHMmDGws7PDwYMHUVJSInQsdLck2VF9Apa7uzvb4SgUa2trTJgwgS5ZEpHCLlPKzgbWrgXc3ABHR0y9cAEDY2IE837kDaFEcvToUaKvr0/Cw8NFen5ZWRk5fvw4GTZsGDEwMCBLly4laWlpjXru/fv3ibGxMSktLRXp2BQzSktLyZw5c0jXrl3J06dP2Q5HYWVnZxN9fX2SlJTEdihyJzw8nDg6OrIdBnNiYghxdiZEU1NwA6pufC5XcJ+zs+BxcoL2hEX05Zdf4ty5c/j+++/x66+/Cl1fWk1NDc7Ozrhw4QKuXbuGkpIS9OrVCw4ODjhz5ky9y5wCAwPh4eEBdXV1cV8GJSJaAUt66JIl0SlUTzg4GBg0CIiMFOwX/1GhJA6PJ7gvMlLwuOBgVsIUGttnAfLu1atXpHfv3mTSpEmkqKhIrLYKCwvJrl27SK9evUi7du3Ib7/9RrKzs2s8Jjc3l+jq6pKsrCyxjkWJLjk5mZibm5OFCxeS8vJytsNRCiUlJaRTp07k7NmzbIciV8rKyoimpiYpLCxkOxTxBAURoqVVo+fb4E1LS/A8GUd7wmIyMjLClStXQAjBoEGDkJmZKXJbWlpamD59OmJjY3HkyBE8fvwYnTt3hpubW1VRkN27d8PBwUGi64+pul24cAEDBgyAj48PnYAlRRoaGli/fj1++OEHlJWVsR2O3KicIf348WO2QxFdbCywaBFQVCTc84qKBM+Li5NMXAyhSZgBXC4XBw8ehKOjI/r27Yu7d++K3Wbv3r2xa9cuPH36FD179sS0adPQrVs3+Pn5YcaMGQxETQkrMDAQU6ZMoROwWFK5ZInusiQcuZ8h7ecHNLAstE48nuD5MowW62BYeHg4PDw8EBISggkTJjDWLp/Ph5+fHwICAgAAkydPhqenp9yujZMntAKW7EhISMDQoUORnJyMFi1asB2OXFi1ahV4PB7WrFnDdijCy84GzMw+uf4rFE1NID29zqqIbKM9YYZNmDAB0dHRWLhwIVatWiX0hK26qKio4Pr169i0aRMSEhLQsmVLDB8+HAMHDsThw4dRWlrKyHGomugELNlSuWRpxYoVbIciN+R6I4c9e8Rvg8Nhph1JYfWKtAJ79eoV6dOnD3F1dRV7whYhhKSkpJBWrVoRHo9XdV9paSk5evQoGTx4MDE0NCQ//vgjefHihdjHogToBCzZVLlk6dGjR2yHIheSkpJIx44d2Q5DNJMnCzcZq67blClsv5I60eFoCeLxeHB3d0dqaioiIyPRpk0bkdtauHAhNDU14VfH9Y2kpCSEhIRg//79sLOzw5w5czB8+HC6u5KILly4ADc3N6xZs4Ze/5VBGzZswJ9//okzZ86wHYrMKy8vR7NmzZCbmwvux7vIsYzP5yMnJwcZGRl4+fJl1dfKf/8SF4ehol4Prs7BATh1Svx2JIAmYQkjhGDNmjUICQlBZGQkevbsKXQbHz58gJmZGe7evQszM7N6H1tYWIhDhw5V1an28PDA9OnT0bJlS1FfgtIJDAzEqlWrcPjwYQwcOJDtcKha0F2WhGNtbY29e/fi888/l9oxCSHIycmpkVw//vrPP/+gWbNmMDU1hYmJSY2vpqam6LFxI5qfPCl+MFOmAHv3it+OBNCtSSSMw+Hgxx9/hIWFBUaNGoWgoCBMnDhRqDYOHDiAAQMGNJiAAaBp06aYOXMm3N3dERMTg6CgIHTq1Anjxo3DnDlz0KdPH8Z3c1IU1Sdg0eu/sq36kqWhQ4fSwjUNqCzawVQSJoTgzZs3DSZYbW3tT5LryJEjq743MTGpv3ceEwOcPy/exCwuV7BlrYyiPWEpunfvHpycnDBjxgz873//+zQZZmcLJhDExwP5+YCODoiNDQbu3o1ftm3D0KFDRTru27dvsXv3bgQHB0NHRwdz5szBpEmT0LRpU/FflIKovgVhWFgYmjdvznZIVAMIIRgxYgTGjx9P66g3YOXKlSguLm7UDGlCCN6+fVtrYq389z///AMtLa1PEmz1ryYmJuJvoagEs6NpEpayrKwsODk5wczMDLt37xa8SWNjBWvZzp4VPKjaG65CQwPlZWXQcHICx9cX6N1b5GPz+XxcuHABQUFBuH79Otzc3ODp6YkuXbqI+7Lk2uPHj+Ho6AgHBwesW7eOFuCQIzWWLJWXf3ISCxsbYPp0mf0Alpbw8HDs27cPERERyM3NrTWxVn7NyMgAl8utMSz8cZI1NjaW3km8iwtIZCQ4oqQqDgdwdgbCw5mPiyE0CbOguLgYM2fOxOPHj3HexQV6v/4qWFRe36+CwxEMqwQEAJ6eYseQnp6O33//HTt37oSFhQXmzJmD8ePHK92wHp2AJf9+mzABo+/fR7dXrwR3VO81cbmCv6vRowExT2JlHSEEubm5tQ4PJycn4969e1BTU0OTJk3q7L1WfpWlUbLia9eAwYOhWU89/TppaQFXrgC9ejEfGENoEmYJIQTnnJww8NQpaAnzK9DSYiwRA4IJLhEREQgKCkJqaipmzpyJWbNmwcTEhJH2ZRmdgKUAgoNBvL3B5/FQ7/gFwyex0kYIQV5eXp3XXyv/raGh8cnkJhMTExgZGcHJyQkvX75EKzkaFcjPz4ejoyOml5RgWmIiOMKUrmT4s1JSaBJmS2ysYKcPYeuhAhI7u3v48CGCg4Nx8OBBDBo0CHPmzMGQIUMUbpkTrYClIIKDha8pLIMfzIQQvHv3rs7EWvlVXV29wWuwzZo1q/M4VlZW2L9/P7p37y7FVye6169fY9So/7d393E13v8fwF9pLLkrUoYxVrk5araltRIR3SmpSdYYsxnyEH5sqlHkpmabb+6Z3G1imj3WEGV9c1MxlZjmplRa8WWFaKlTzjnv3x/n2/lq7qpzc51O7+fj4eGmcz7X+0r1uq7rc+cGR0dHREdHo9XWrfL/bw0/NVQ3DmGh+PrKt9zSwn6OyspKxMbGYtOmTaiursasWbMwdepUGBsbq+V4msQDsHSEFl7EPg0R4cGDB88M1rrf9fX1nxmwdX9+XsA2hL+/P7y9vREQEKCis1OfP//8E6NHj0ZAQADCw8P/N4g1K0s+fubIEfnPwcfnENd1PXh4yLsetPgR9OM4hIXQTEb8ERHOnDmDTZs2ISEhAT4+PggMDIRNM/ni/icegKVDtOAilohQUVHx3Gk6N27cgJ6e3gv7YDVxMbhs2TLU1tZi5cqVaj+WMq5cuQJXV1csWLAAc+fOffqLysrkg/BycoDycsDYWD4NaerUZjcIj0NYCKtXA+Hhys99W7YM+Owz1dX1HGVlZdixYwe2bNkCExMTBAYGwt/fX/kpCBrCA7B0iIYuYp8VsI//GcBzA/bVV1/VmqctBw4cwJ49exAfHy90Kc+UlZUFLy8vfPnll/jwww+FLkcjOISFMGkSEBurfDsCrAIjlUqRlJSETZs24bfffsOHH36ImTNnwtLSUqN1NAYPwNIxKriIJQMD/DV7Ni66uDzzMbFMJnvmFJ263zt27NhsFr+5cuUKvL29kZeXJ3QpT3X8+HH4+/sjJiYGY8eOFbocjeEVs4Tw4IFq2ikvV007jaCvrw8PDw94eHjg+vXr+Pbbb+Ho6Ahra2sEBgbCy8sLL72kHV9WvAKWjrp4Ubm7YAB6YjF+27YNG3//XRGotra2eO+99xR/79SpU7MJ2IYwNzdHSUkJxGIxDAwMhC6nnl9++QXTp09HXFwcnJychC5Hs9S9QwR7Ch3bGUQsFlNsbCw5ODhQz549admyZfSf//xH0Jru3btHzs7O5O7uTg8ePBC0FqZinp6q+f7x9BT6TDROJBLRhQsXhC6jnt27d1O3bt0oMzNT6FIEoVtzT5oLa2t5n5QSZC+/rDXrob788ssICAhAWloaEhIScOvWLYhEIvj5+eH48ePK76lcWip/BDlpEuDlJf999Wr54IynyM3NxTvvvANra2scOnRIa/rkmIp06qSadnRgtH9jDRw4UKv2Fl67di0WL16MlJSUZjvgU2lCXwW0SH/9RWRgoNRVfDVA07y8KDs7W+izeaoHDx7Qxo0bSSQSUf/+/Wnt2rVUXl7euEYyMoh8fOSfq39+vtq2lf+bj4/8df917NgxMjU1pZiYGBWfEdMaX36p9PcPtW1LtHq10GeicUuXLqUvvvhC6DJIJpNRWFgYWVhYUFFRkdDlCIpDWCg+PkR6ek37AaKnR4/GjqU1a9ZQ9+7dyd3dnVJTU4U+o6eSyWR06tQpmjhxIhkZGdEnn3zSsAuHTZuIDA1f/DnS05O/btMm2rBhA5mZmdHJkyfVf2JMEDKZjE7++CPVtGqlXAgbGBCVlgp9OhoXFxdH48aNE7QGqVRKc+bMocGDB9Nff/0laC3agENYKBkZ8vBoyg8QQ0Oi//afiMVi2rp1K/Xt25ccHR0pMTGRZDKZwCf3dLdv36aVK1dSr169yM7Ojnbv3k3V1dVPvrAugBvxORG/9BIt7daNCgoKNH9iTO2qq6tp+/btZGVlRQMHDqTCwYNJpsRFLPn6Cn1Kgrh06RJZWloKdvza2lqaNGkSOTo60v379wWrQ5twCAupCWFTd9f3T48ePaLY2FgSiUT01ltv0YEDB0gqlQpwUi8mkUjo4MGD5ObmRl27dqWFCxdSfn6+/INKXJzI2rZVXJww3XDr1i0KCwsjMzMzcnd3p6SkJPlFpoouYluampoaMjAwePrFr5pVVVWRp6cnjRkzhh4+fKjx42srDmGhNeGx6/NIpVKKj48nW1tb6t+/P+3evZtqa2s1dDKNl5+fT5999hl17dqV3Nzc6OY77/AdDqPz58/TlClTyMjIiGbOnElXrlx58kUqvIhtSQYOHEi///67Ro95//59GjZsGAUEBGj1zyMhcAhrg8xMeXgYGMgHjDz+Q6NuAJKvb6Ou3mUyGSUnJ9PIkSOpd+/etHHjRqqqqlLjSSinurqa4jZsIHFTA7iF9/XpAolEQvHx8eTk5EQ9evSgyMhIunv37vPfpOKL2JZg/PjxtHfvXo0dr7S0lN566y2aPXu21j6dExKHsDYpLZWP2Jw8WT6HcfJk+d+VDJUzZ86Ql5cXdevWjb788kuqqKhQUcEqxqNeW6SKigpau3Ytvf7662Rra0v79u1r3N2SGi5idVl4eDgtXrxYI8f6888/qV+/frRkyRKtHasiNO1Y2ojJde2qlrWg7ezscPDgQVy8eBFRUVHo27cvAgMDERQUhC5duqj8eE2mgpWQUF0tX9Sdab2ioiKsX78eu3btgrOzM77//nvY2dk1fpUqGxv5Zgw6tKi/Og0cOBA//PCD2o+Tm5sLFxcXzJ8/H/PmzVP78ZorDuEWxNraGnv37sW1a9ewevVqWFhY4KOPPsKCBQvQvXt3octr1st5soYhIqSnpyM6OhonTpzAtGnTkJ2djd69eyvfuJouYnWNSCRS+4Id2dnZGDNmDCIjIzF16lS1Hqu54xWzWiALCwts27YNFy9ehEwmw6BBgzBz5kwUFhYKWxivhKSzamtrERsbC1tbW0ybNg0jRoxAUVERVq9erZoAZg1mYWGB4uJi1NTUqKX9kydPws3NDZs3b+YAbgAO4RasZ8+e+Ne//oXc3FyYmJjA1tYWkydPFm5ZOxUs54m2bbVmOU8G3LlzB6tWrUKfPn2wY8cOhIeH4+rVq5g9ezbat28vdHktUps2bdCnTx/k5uaqvO1Dhw7Bz88PP/zwA8aNG6fy9nURhzBD165dsWLFChQUFEAkEsHZ2Rk+Pj7IzMzUbCEquGomIpW0w5Rz+fJlfPrpp7CwsEBBQQGOHj2Kf//73/D09ESrVvxjR2gikQiXL19WaZt79uzB9OnTkZCQgJEjR6q0bV3G3w1MoVOnTggODkZhYSFGjhyJ9957Dy4uLjhx4oQ83NTN1BRwdweauH2cFEBq+/b4raBAtXWxBpHJZEhMTISrqyucnZ3Rs2dP5ObmYvv27bC2tha6PPYYVW/ksH79eoSEhCAlJQVDhgxRWbstAYcwe4KhoSHmzJmD/Px8vP/++5gxYwYcHBxw+PBh9YdxSIj8kXITtDI0RPnMmZgwYQLGjRunVbvF6LKqqips3boVIpEIwcHBCAgIQFFREcLCwmBqaip0eewpVHUnTERYtmwZ1q1bh9TUVAwcOFAF1bUwgk6QYs2CRCKh/fv30xtvvEHW1ta0b98+kkgk6jugkishVVdX0zfffEOmpqY0ZcoUun79uvpqbcFu3LhBwcHBZGJiQt7e3nT8+HGeC9pM5OTkUL9+/ZRqQyqVUlBQEL3xxht0+/ZtFVXW8nAIswaTyWSUkJBA9vb2ZG5uTjExMVRTU6Oeg6lgJaT79+/TkiVLqHPnzhQUFMQ7tqhIRkYGvf/++2RsbExBQUF07do1oUtijVS3hrRYLG7S+2tra2ny5Mnk4ODQ+C1KWT38OJo1mJ6eHjw8PJCWloaYmBjExcXh9ddfx7p161BVVaXag82aBZw8Cfj4yEdM//MRddu28n/38ZG/btasJ5ro1KkTIiIicOXKFQDAgAEDEB4ejoqKCtXW2gJIJBL8+OOPcHBwgJ+fH2xsbHD9+nWsXbsW5ubmQpfHGqlNmzZ47bXXkJeX1+j3isVijB8/Hnfu3MGxY8dgZGSkhgpbDj0iTYy4YboqKysLkZGRSEtLw9y5cxEYGKj6b0oVrYRUVFSEpUuX4ujRo1i0aBECAwNhoOyUKB13//59xMTEYP369Xj11Vcxf/58eHt746WXeJ2f5m78+PHw8/ODv79/g99TUVEBb29vdOvWDbt370abNm3UWGHLwCHMVOLy5cuIiorCkSNHMGPGDMydO1drB+X88ccfWLx4MbKzsxEeHo4pU6ZwqPzDtWvXsG7dOsTGxsLDwwNz587lUa86JiwsDAAQERHRoNeXlZXB3d0dQ4YMwYYNG6Cvr6/O8loMfhzNVGLgwIH47rvvkJmZifLycvTv3x9z585FSUmJ0KU9YdCgQYiPj0dcXBy+//57DBo0CAcOHNDMNCwtRkRISUnB2LFjYW9vj44dOyInJwd79uzhANZBjRkhXVJSgmHDhsHNzQ2bNm3iAFYhvhNmanHr1i2sWbMG27dvh4+PDxYtWgRLS0uhy3oCEeHYsWMICQmBvr4+IiMjMWrUKKHL0iixWIx9+/YhOjoajx49wrx58zBp0iQYGhoKXRpTo8snTiBhwgR85uIiX7e9Uyf5qnUffVSvmycvLw8uLi6YM2cOFixYIGDFOkqwIWGsRbh79y4tXbqUTExMyN/fny5cuCB0SU8llUpp//79ZGFhQSNHjqSzZ88KXZLa3b59m8LDw8nMzIzc3NwoMTGRpxi1BBkZRD4+JHv5ZXr4tK1ADQyIfHyIMjLo3Llz9Morr9D27duFrlpncQgzjaioqKCvvvqKXnnlFRozZgydPn1a6JKeqra2lr799lvq0aMH+fr60uXLl4UuSeUuXLhAU6dOJSMjI5oxYwZdunRJ6JKYpjRi6p/k5ZdpYfv29NNPPwldtU7jPmGmER06dMDChQtRWFgIT09PBAQEYMSIEfj111+1qi+2devWmD59Oq5duwY7OzsMHz4c06ZNQ3FxsdClKUUqleLgwYMYOXIkxowZA0tLS+Tn52PLli28ylFLsXkzsHAhUFUlj9rnIYJ+TQ2iHj2C719/aaa+For7hJkgHj16hP379yMyMhLt2rVDaGgoxo4dq3WL+9+/fx9ff/01Nm/ejA8//BChoaHo2ow2iP/777+xa9curF27FsbGxpg/fz78/PzQunVroUtjmpSZCTg5yQO4sQwN5XPxbWxUXhbj0dFMIK1bt8akSZOQk5ODkJAQrFixAlZWVtizZw8kEonQ5SkYGRlhxYoVuHTpEiQSCfr3749ly5bh77//Frq05yoqKsLChQvx2muv4dSpU9i9ezcyMjIQEBDAAdwSRUYC1dVNe291tfz9TC04hJmgWrVqpdg2MTo6GjExMbC0tMSWLVsgFouFLk+hW7duWL9+PbKyslBQUABzc3NER0drVY1EhPT0dIwfPx5vv/02ACA7O1ux0pVeE3enYs1caSlw9OiLH0E/CxFw5Ih80RymchzCTCvo6elh9OjROHHiBL7//nscPnwYr7/+Or755htUVlYKXZ5Cnz598N133yE5ORkpKSno168fdu7cKejde21tLfbu3QtbW1tMmTIFw4cPR1FREb7++mv07t1bsLqYlti1S/k29PRU0w57Aocw0zp12yYmJCQgIyMDffr0wbJly3Dv3j2hS1OwsrLCwYMHsW/fPuzcuRPW1tb4+eefNTrI7O7du4iMjETfvn0RExODsLAw5ObmYs6cOejQoYPG6mBa7uJFQNknNtXV8mVjmcpxCDOtNXjwYOzfvx/p6ekoLi6GhYUFPv/8c9y6dUvo0hTs7e1x8uRJfPPNN4iIiICdnR1SUlLUeswrV65gxowZMDc3R15eHhISEpCSkgIvLy9eyYg96cED1bRTXq6adlg9HMJM61laWmL79u04f/48ampqIBKJEBgYiKKiIqFLAyB/lO7u7o5z585h/vz5+PTTT+Hi4oKsrCyVHYOIkJSUBDc3N4wYMQLdu3fH1atXsXPnTrzxxhsqOw7TLbdv30bB3buqaczYWDXtsHo4hFmz0atXL6xduxZXr16FkZER3n77bUyZMkWxVaHQWrVqhYkTJ+LKlSvw9fWFt7c3/Pz8kJub2+Q2q6qqsHXrVohEInz++eeYOHEiioqKEB4eDjMzMxVWz3RBbW0tTpw4geDgYLz55psYMGAATldWQqLsiPi2beU7lzGV4xBmzY6pqSlWrVqFgoIC9OvXD05OTnjvvfdw7tw5oUsDIJ9+NXPmTFy7dg02NjYYOnQoPvnkk0ZtZnHz5k2Ehoaid+/eSEhIwMaNG3HhwgVMnTqVt19k9RQWFmLz5s3w9vZG165d8fnnn6NNmzbYuHEjysrKMDk5GS8p201BJN86lKkchzBrtoyMjBAaGorCwkIMGzYM48aNg6urK06dOqUVq3AZGhpi0aJFyMvLg6mpKQYPHowFCxbgzp07z3xPZmYmPvjgA1hZWaGyshKnT5/GwYMHMWLECJ5ixAAADx8+REJCAoKCgmBpaQkHBwecPXsWEydOREFBATIyMhAREQF7e3v5Fp2mpoC7u3yEc1Po6QEeHo3au5s1HK+YxXRGTU0N9uzZg6ioKJiZmSE0NBTu7u5aE163bt3C8uXLERcXh7lz52L+/Plo3749JBIJ4uPjER0djZKSEgQFBeHjjz+GkZGR0CUzLUBEuHTpEhITE5GYmIizZ8/CxsYGbm5ucHV1hbW19YtXmuMVs7QWhzDTORKJBAcOHMCqVaugr6+P0NBQ+Pr6as3I4YKCAoSFhSE5ORnvvvsuzp8/j1dffRXz5s3DuHHj5HcvrEW7d+8ekpOTkZSUhKSkJLRp0wZubm6KgXlNmoL2+NrRDWVoCHz9NTBrVuOPxxqEQ5jpLCLC4cOHsXLlSpSXlyM4OBiTJk1q/LKNpaXyhQouXnzuvqsNlZ+fj3Xr1mHXrl3o0KEDiAhRUVH44IMPtOZCgWmWVCpFVlYWEhMTkZSUhD/++APDhg2Dq6sr3NzcYG5urponOnVBXF39/BW09PTkg7E4gNVP8xs3MaZZMpmMUlJSaNSoUdSrVy9av349VVVVvfiN/913lQwM5L+es+9qQ2sYO3YsmZiYUEhICJWUlBAR0alTp8jBwYFEIhHFx8fznr4txM2bN2nnzp3k7+9PnTt3JisrK1q4cCElJyeTWCxW34EzM4l8feVfv23bPv3r2tdX/jqmdnwnzFqUjIwMREZG4syZM5g3bx5mzZqFTp06PflCFd0x1NTUYN++fYiOjkZNTQ3mzZuHyZMnw9DQsN7riAhHjhxBSEgI2rVrh8jISDg5OSl5tkyb1NTUID09XXG3W1JSgtGjR8PV1RWurq7o0aOHZgsqK5M/4cnJkS/EYWwsrg1mCgAACLJJREFUn4Y0dSoPwtIkgS8CGBNETk4OffDBB9SlSxdavHgxlZWV/e+DdRufP2/T83/+MjSUv++/bt++TUuXLiUzMzNycXGho0ePklQqfWFdUqmU9uzZQ3379iVXV1c6d+6cOk6faUh+fj5t2LCBPD09qWPHjvTOO+9QeHg4nTlzhiQSidDlMS3Ad8KsRSsoKMBXX32FuLg4TJkyBcHOzjDz92/yKNK8bdsQlZyMn3/+GRMmTEBQUBBEIlGjm6qtrUVMTAxWrFgBR0dHLF++HJaWlo2viWlUZWUljh8/jqSkJCQmJqKqqkrRrztq1Ch06dJF6BKZluEQZgzyxTHWrFmDEevXw+PRoyZNoJcBSDQwwIUlS/Dpp5/CxMRE6boePnyIdevWYc2aNfD19UVYWJjmH1uyZyIi5OTkKKYPZWZmwtbWVjF9yMrKSmumyDHtxCHMWJ3SUlCvXtCrqWlyE2RgAL3iYpX3qd27dw+rV6/Gtm3b8PHHHyM4OBidO3dW6TFYw9y9exfJycmKvt127dop7nadnJzQvn17oUtkzQivmMVYnV27lL5r0VPTvqudO3dGVFQULl68iIqKCvTr1w8rV67Ew4cPVX4sVp9UKsWZM2cQHh4OOzs79O3bF7GxsbCxscGpU6dw7do1bNiwAZ6enhzArNE4hBmr0wz2Xe3Rowe2bNmC06dP448//oC5uTk2btyI2tpatR2zJbp58yZ27NiBCRMmwNTUFDNnzoRYLEZkZCRKS0tx8OBBzJ49G+bm5kKXypo5fhzNWB0vL+DwYeXb8fQEDh1Svp0GOH/+PEJDQ5Gbm4uIiAi8//77vOBHE9TU1CA1NVUxoOrWrVsYNWoU3Nzc4OLigu7duwtdItNRHMKM1Zk0CYiNVbqZMnd3GP3yS+NX5lLCyZMnERISgsrKSqxatQpjxozhAUHPQUTIz89XDKhKTU3FoEGDFAOqbGxs+GKGaQSHMGN1Vq8GwsOVeiRdq6+PDV27IryyEkOGDIGjoyOGDh0KOzu7pq332whEhEOHDuGLL75Ax44dERkZiWHDhqn1mM3J33//jePHjyuCt7a2VjGgytnZmQe6MUFwCDNWp7QU6N1buX5hAwOguBj3W7fG6dOnkZaWhrS0NGRnZ6Nfv36KUB46dCi6deumutofI5VKsXfvXoSFhWHAgAFYtWoVBg8erJZjaTMiwu+//64YxZyVlQU7OztF8IpEIn5awATHIczY43x9gfj45y9V+Sx6eoCPD/DTT098qKamBllZWYpQTk9PR+fOneuFsqWlpUpDoaamBtu2bcPKlSvh5OSE5cuX6/xAojt37uDXX39FYmIijh07hg4dOih2Hxo+fDjatWsndImM1cMhzNjjNLTvqkwmw+XLlxWhnJaWhqqqKkUgDx06FG+++aZK+pUrKysRHR2N6Oho+Pn5YcmSJToz0EgikeDs2bOKu93c3Fw4OTkp+nb79u0rdImMPReHMGP/JNC+qyUlJfVCubCwELa2topQfvfdd5Wah3r37l1ERUVhx44dmD59OhYtWgRjY+MmtyeUkpISxSjmlJQU9O7dWxG69vb2aNOmjdAlMtZgHMKMPY0W7LtaXl6OM2fO1OtX7t+/f7275ab0K9+4cQMRERH4+eefsWDBAgQFBT2xq9MzqXhv5YYQi8U4deqUInhLS0sxevRoxfQhdfWtM6YJHMKMPUtWFhAZCRw5Ig/b6ur/faxtW3k4e3gAISENegStLLFYjHPnztXrV+7SpYsikB0dHWFhYdHgfuXc3FwsWbIEaWlpWLJkCT755JNnP/7OzJR/Lo4erSvmfx+r+1y4u8s/F0OGKHWeRIS8vDzFI+a0tDRYW1sr7nbfeustnj7EdAaHMGMvoqX7rj7er5yamoq0tDRUV1fXC+XBgwe/sF/53LlzCA0NRUFBASIiIjBx4kS0avXYYnoaeCpQUVGBlJQURfBKJBLFgCpnZ2cYGRk1qj3GmgsOYcZ0SHFxMdLT0xWhfP36dUW/sqOjI+zs7J7Zr3z8+HGEhIRALBZj1apVcHd3h96WLWrpH5fJZLhw4YIidLOzs2Fvb6+YPjRgwACePsRaBA5hxnTY4/3KqampOH/+vKJf2dHREQ4ODvX6VIkIv/zyC7744gvYt26NLVevQr8pu0o9ZaR4WVkZjh07ppg+ZGxsrHjEPHz48Ib3SzOmQziEGWtB6vqV6+6U09PTYWJiUm++soWFBWQyGW7Y2qJndjaa1PuqpweZtzfS/+//FAOq8vPzMWLECEXwvvbaayo+O8aaHw5hxlqwun7lulCu61ceM2QIth07hpckkia3LQYwxsoKdl5ecHV1xbvvvqvR9bQZaw44hBlj9RQXF+PuokUQ/fgj2kilTW5HZmCAVhERwGefqbA6xnTLS0IXwBjTLr169UIvfX1AiQAGgFZisVr3VmZMF7R68UsYYy3Ogweqaae8XDXtMKajOIQZY0/q1Ek17TTDZTEZ0yQOYcbYk6yt5dsyKqNtW/miJoyxZ+KBWYyxJ6lwb2UhVxVjTNvxnTBj7EmmpvK1oJu6apWennxdbQ5gxp6L74QZY0+nob2VGWvJ+E6YMfZ0Q4bI14Bu7HKSdWtHcwAz9kI8T5gx9mx1mzAIvLcyY7qKH0czxl5My/ZWZkxXcAgzxhpOS/dWZqy54hBmjDHGBMIDsxhjjDGBcAgzxhhjAuEQZowxxgTCIcwYY4wJhEOYMcYYEwiHMGOMMSYQDmHGGGNMIBzCjDHGmEA4hBljjDGBcAgzxhhjAuEQZowxxgTCIcwYY4wJhEOYMcYYEwiHMGOMMSYQDmHGGGNMIBzCjDHGmEA4hBljjDGBcAgzxhhjAuEQZowxxgTCIcwYY4wJhEOYMcYYEwiHMGOMMSYQDmHGGGNMIBzCjDHGmEA4hBljjDGBcAgzxhhjAuEQZowxxgTCIcwYY4wJhEOYMcYYEwiHMGOMMSaQ/wc2wrU85cf4iwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x154bce896d10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "nx.draw(G)\n",
    "plt.savefig(\"path.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "writes to the file `path.png` in the local directory. If Graphviz and\n",
    "PyGraphviz or pydot, are available on your system, you can also use\n",
    "`nx_agraph.graphviz_layout(G)` or `nx_pydot.graphviz_layout(G)` to get the\n",
    "node positions, or write the graph in dot format for further processing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x154bce646f50>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from networkx.drawing.nx_pydot import write_dot\n",
    "pos = nx.nx_agraph.graphviz_layout(G)\n",
    "nx.draw(G, pos=pos)\n",
    "write_dot(G, 'file.dot')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See Drawing for additional details."
   ]
  }
 ],
 "metadata": {},
 "nbformat": 4,
 "nbformat_minor": 2
}