Project_Main.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CMPE 232 Project : Mimicking TensorFlow\n",
    "\n",
    "## Group Name: Placeholder\n",
    "\n",
    "### Members:\n",
    "#### - Hasan Kemik 116207076\n",
    "#### - Ali Çağan Keskin 116200079"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Index\n",
    "- [Needed Libraries](#Needed-Libraries)\n",
    "- [Classes](#Classes)\n",
    "- [Functions](#Functions)\n",
    " + [Understanding Math Operation](#Understanding-Math-Operation)\n",
    " + [Forward Propogation Function](#Forward-Propogation-Function)\n",
    " + [Backward Propogation Function](#Backward-Propogation-Function)\n",
    "- [User Input](#String)\n",
    "- [Graphical Representation of the String](#Graphical-Representation-of-the-Equation)\n",
    "- [Graphical Representation of the Reversed String](#Graphical-Representation-of-the-Reverse-Graph)\n",
    "- [Forward Propogation](#Forward-Propogation)\n",
    "- [Backward Propogation](#Backward-Propogation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Needed libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from functools import reduce #python 3\n",
    "import operator\n",
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# class for addition\n",
    "class add():\n",
    "    def __init__(self,inputs):\n",
    "        self.inputs = inputs\n",
    "        \n",
    "    def compute(self):\n",
    "        return sum(self.inputs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# class for substraction\n",
    "class subtract():\n",
    "    def __init__(self,inputs):\n",
    "        self.inputs = inputs\n",
    "        \n",
    "    def compute(self):\n",
    "        return (self.inputs[1] - self.inputs[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# class for division\n",
    "class division():\n",
    "    def __init__(self,inputs):\n",
    "        self.inputs = inputs\n",
    "        \n",
    "    def compute(self):\n",
    "        return (self.inputs[0] / self.inputs[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# class for matrix multiplication\n",
    "class matmul():\n",
    "    def __init__(self,inputs):\n",
    "        self.inputs = inputs\n",
    "        \n",
    "    def compute(self):\n",
    "        if len(self.inputs[0]) > 1:\n",
    "            x = self.inputs[0]\n",
    "            for y in self.inputs[1:]:\n",
    "                x = np.dot(x,y)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# class for activation function\n",
    "class sigmoid():\n",
    "    def __init__(self,inputs):\n",
    "        self.inputs = inputs\n",
    "        \n",
    "    def compute(self):\n",
    "        return 1 / (1 + np.exp(-self.inputs[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# class for multiplication\n",
    "# try except block is used if the one of the inputs are a number and other one is a matrix.\n",
    "class multiply():\n",
    "    def __init__(self, inputs):\n",
    "        self.inputs = inputs\n",
    "        \n",
    "    def compute(self):\n",
    "        try:\n",
    "            x = reduce(lambda x, y: x * y, self.inputs, 1)\n",
    "        except:\n",
    "            x = self.inputs[0]*self.inputs[1]\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# class that holds varible\n",
    "class Variable(): \n",
    "    def __init__(self, initial_value):\n",
    "        self.value = initial_value\n",
    "    \n",
    "    def compute(self):\n",
    "        return self.value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# class for placeholder\n",
    "class Placeholder(): \n",
    "    def __init__(self,value = None):\n",
    "        self.value = value\n",
    "        \n",
    "    def change_value(self,value):\n",
    "        self.value = value\n",
    "    \n",
    "    def compute(self):\n",
    "        return self.value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# class for Nodes\n",
    "# input attribute is the list of nodes which comes into the node\n",
    "# output attribute is the list of nodes which goes from the node\n",
    "# n_type attribute is the Type of Node. With this attribute, we can \n",
    "# classify the Node's operation.\n",
    "\n",
    "# The node type can be Add, MatMul, Multiply, Sigmoid, Subtract,\n",
    "# Division, Variable, Placeholder.\n",
    "\n",
    "# This way, we can choose which class that we defined above, will be used for operation.\n",
    "class node():   \n",
    "    def __init__(self,inputs,outputs,n_type):\n",
    "        \n",
    "        self.inputs = inputs\n",
    "        self.outputs = outputs\n",
    "        self.n_type = n_type\n",
    "        \n",
    "        if len(n_type) > 1 and n_type[0] == \"Operation\":\n",
    "            \n",
    "            if n_type[1] == \"Add\":\n",
    "                self.value = add(inputs)\n",
    "            elif n_type[1] == \"MatMul\":\n",
    "                self.value = matmul(inputs)\n",
    "            elif n_type[1] == \"Multiply\":\n",
    "                self.value = multiply(inputs)\n",
    "            elif n_type[1] == \"Sigmoid\":\n",
    "                self.value = sigmoid(inputs)\n",
    "            elif n_type[1] == \"Subtract\":\n",
    "                self.value = subtract(inputs)\n",
    "            elif n_type[1] == \"Division\":\n",
    "                self.value = division(inputs)\n",
    "            else:\n",
    "                self.value = null\n",
    "                print(\"Please check the operation parameter you've given.\")\n",
    "        \n",
    "        elif n_type == [\"Variable\"]:\n",
    "            self.value = Variable(inputs)\n",
    "            \n",
    "        elif n_type == [\"Placeholder\"]:\n",
    "            self.value = Placeholder()\n",
    "            \n",
    "    \n",
    "    def compute(self):\n",
    "        return self.value.compute()\n",
    "    \n",
    "    def change_value(self,val):\n",
    "        self.value.change_value(val)\n",
    "    \n",
    "    def change_inp(self,inp):\n",
    "        self.value.inputs = inp\n",
    "        \n",
    "    def return_val(self):\n",
    "        return self.value.value\n",
    "    \n",
    "    def return_type(self):\n",
    "        return self.n_type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the class which visualises the graph.\n",
    "class draw_graph():\n",
    "    def __init__(self,node_list,edge_list,color_map,label_dict):\n",
    "        self.G = nx.DiGraph()\n",
    "        self.color_map = color_map\n",
    "        self.G.add_nodes_from(node_list)\n",
    "        self.G.add_edges_from(edge_list)\n",
    "        self.G = nx.relabel_nodes(self.G,label_dict)\n",
    "    \n",
    "    def draw(self):\n",
    "        nx.draw_spring(self.G,node_color = self.color_map ,node_size = 500, with_labels = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the class which visualises the reversed graph.\n",
    "class draw_reverse_graph():\n",
    "    def __init__(self,node_list,edge_list,color_map,label_dict):\n",
    "        self.color_map = color_map\n",
    "        self.G = nx.DiGraph()\n",
    "        edge_list = reversedGraph().reverse(edge_list)\n",
    "        self.G.add_nodes_from(node_list)\n",
    "        self.G.add_edges_from(edge_list)\n",
    "        self.G = nx.relabel_nodes(self.G,label_dict)\n",
    "        \n",
    "    def draw(self):\n",
    "        nx.draw_circular(self.G,node_color = self.color_map ,node_size = 500, with_labels = True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the class which reverses the graph\n",
    "class reversedGraph(): \n",
    "    @staticmethod\n",
    "    def reverse(edge_list):\n",
    "        reversed_elist = [(t,s) for s, t in  edge_list]\n",
    "        return reversed_elist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the class for Depth First Search\n",
    "class DirectedDFS():\n",
    "    def __init__(self, G, node_list):\n",
    "        self.G = G\n",
    "        self.visited = {node_name: False for node_name in node_list}\n",
    "        self.traversal = []\n",
    "        \n",
    "    def dfs(self, sname):\n",
    "        self.visited[sname] = True\n",
    "        self.traversal.append(sname)\n",
    "        for neighbor in sname.inputs:\n",
    "            try:\n",
    "                if (not self.visited[neighbor]):\n",
    "                    self.dfs(neighbor)\n",
    "            except:\n",
    "                continue\n",
    "    def return_traversal(self):\n",
    "        x = self.traversal\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Understanding Math Operation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# since that the equation will be given as a String,\n",
    "# this is the function for understand the characters \n",
    "# we will be using djikstra's two stack algorithm to inspect the equation.\n",
    "# First, we created some empty lists and read the string one time to create variable and placeholder nodes,\n",
    "# after to create the operation nodes, using djikstra's two stack algorithm, we read the string once again.\n",
    "\n",
    "\n",
    "def math_operands_split(mat_op):\n",
    "    operators = [\"+\",\"-\",\"/\",\"*\",\":\",\"|\"]\n",
    "    op_stack = []\n",
    "    numb_stack = []\n",
    "    numb_stack_cont = []\n",
    "    op_stack_cont = []\n",
    "    placeholder_nodes = []\n",
    "    variable_nodes = []\n",
    "    variable_dict = {}\n",
    "    label_dict = {}\n",
    "    operation_nodes = []\n",
    "    placeholder_nodes2 = []\n",
    "    variable_nodes2 = []\n",
    "    operation_nodes2 = []\n",
    "    edge_list = []\n",
    "    color_map = []\n",
    "    node_list = []\n",
    "    mat_op = mat_op.split()\n",
    "    \n",
    "    if len(mat_op) == 1 and type(mat_op[0]) == str:\n",
    "        mat_op = list(mat_op[0])\n",
    "        for char in mat_op:\n",
    "            if char in operators:\n",
    "                op_stack_cont.append(char)\n",
    "            elif char not in operators and char != '(' and char != ')':\n",
    "                numb_stack.append(char)\n",
    "                numb_stack_cont.append(char)\n",
    "        placeholder_nodes.append([node([],[],[\"Placeholder\"]) for x in range (len(numb_stack)+1)])\n",
    "        variable_nodes.append([node([x],[],[\"Variable\"]) for x in numb_stack])\n",
    "        \n",
    "        numb_stack = []\n",
    "        op_stack = []\n",
    "        i = 0\n",
    "        for char in mat_op:\n",
    "            if char == ')' and len(op_stack) > 0:\n",
    "                operation = op_stack.pop()\n",
    "                val1 = numb_stack.pop()\n",
    "                val2 = numb_stack.pop()\n",
    "                if operation is '+':\n",
    "                    x = (node([val1,val2],[],[\"Operation\",\"Add\"]))\n",
    "                    operation_nodes.append(x)\n",
    "                    label_dict[x] = (\"+\"+ \"/\" +str(i))\n",
    "                    i = i + 1\n",
    "                    numb_stack.append(x)\n",
    "                elif operation is '*':\n",
    "                    x = (node([val1,val2],[],[\"Operation\",\"Multiply\"]))\n",
    "                    operation_nodes.append(x)\n",
    "                    label_dict[x] = (\"*\"+ \"/\" +str(i))\n",
    "                    i = i + 1\n",
    "                    numb_stack.append(x)\n",
    "                elif operation is '-':\n",
    "                    x = (node([val1,val2],[],[\"Operation\",\"Subtract\"]))\n",
    "                    operation_nodes.append(x)\n",
    "                    label_dict[x] = (\"-\"+ \"/\" +str(i))\n",
    "                    i = i + 1\n",
    "                    numb_stack.append(x)\n",
    "                elif operation is '/' or operation is \":\":\n",
    "                    x = (node([val1,val2],[],[\"Operation\",\"Division\"]))\n",
    "                    operation_nodes.append(x)\n",
    "                    label_dict[x] = (\"/\"+ \"/\" +str(i))\n",
    "                    i = i + 1\n",
    "                    numb_stack.append(x)\n",
    "                elif operation is '|':\n",
    "                    x = (node([val1,val2],[],[\"Operation\",\"MatMul\"]))\n",
    "                    operation_nodes.append(x)\n",
    "                    label_dict[x] = (\"|\"+ \"/\" +str(i))\n",
    "                    i = i + 1\n",
    "                    numb_stack.append(x)\n",
    "            elif char in operators:\n",
    "                op_stack.append(char)\n",
    "            elif char not in operators and char != '(' and char != ')':\n",
    "                numb_stack.append(char)\n",
    "                    \n",
    "        while len(op_stack) > 0:\n",
    "            operation = op_stack.pop(0)\n",
    "            val1 = numb_stack.pop(0)\n",
    "            val2 = numb_stack.pop(0)\n",
    "            if operation is '+':\n",
    "                x = (node([val1,val2],[],[\"Operation\",\"Add\"]))\n",
    "                operation_nodes.append(x)\n",
    "                label_dict[x] = (\"+\"+ \"/\" +str(i))\n",
    "                i = i + 1\n",
    "                numb_stack.append(x)\n",
    "            elif operation is '*':\n",
    "                x = (node([val1,val2],[],[\"Operation\",\"Multiply\"]))\n",
    "                operation_nodes.append(x)\n",
    "                label_dict[x] = (\"*\"+ \"/\" +str(i))\n",
    "                i = i + 1\n",
    "                numb_stack.append(x)\n",
    "            elif operation is '-':\n",
    "                x = (node([val1,val2],[],[\"Operation\",\"Subtract\"]))\n",
    "                operation_nodes.append(x)\n",
    "                label_dict[x] = (\"-\"+ \"/\" +str(i))\n",
    "                i = i + 1\n",
    "                numb_stack.append(x)\n",
    "            elif operation is '/' or operation is \":\":\n",
    "                x = (node([val1,val2],[],[\"Operation\",\"Division\"]))\n",
    "                operation_nodes.append(x)\n",
    "                label_dict[x] = (\"/\"+ \"/\" +str(i))\n",
    "                i = i + 1\n",
    "                numb_stack.append(x)\n",
    "            elif operation is '|':\n",
    "                x = (node([val1,val2],[],[\"Operation\",\"MatMul\"]))\n",
    "                operation_nodes.append(x)\n",
    "                label_dict[x] = (\"*\"+ \"/\" +str(i))\n",
    "                i = i + 1\n",
    "                numb_stack.append(x)\n",
    "            \n",
    "# Creating nodes and initializing links between them is finished by reading the string twice.\n",
    "# In the for nodes below, node list and edge list creations is finished with along color map and label dictionary\n",
    "# for a human friendly representations of the nodes.\n",
    "            \n",
    "        for nodes in variable_nodes:\n",
    "            for my_node in nodes:\n",
    "                variable_nodes2.append(my_node)\n",
    "                node_list.append(my_node)\n",
    "                \n",
    "        for nodes in placeholder_nodes:\n",
    "            for my_node in nodes:\n",
    "                placeholder_nodes2.append(my_node)\n",
    "                node_list.append(my_node)\n",
    "        \n",
    "        for nodes in operation_nodes:\n",
    "            operation_nodes2.append(nodes)\n",
    "            node_list.append(nodes)\n",
    "        \n",
    "        i = 0\n",
    "        for my_node in placeholder_nodes2[:-1]:\n",
    "            edge_list.append([variable_nodes2[i],my_node])\n",
    "            i = i + 1\n",
    "        \n",
    "        for my_node in operation_nodes2:\n",
    "            for inputs in my_node.inputs:\n",
    "                edge_list.append([inputs,my_node])\n",
    "        \n",
    "        i = 0    \n",
    "        for nodes in variable_nodes2:\n",
    "            placeholder_nodes2[i].inputs = nodes\n",
    "            variable_dict[numb_stack_cont[i]] = nodes\n",
    "            label_dict[nodes] = (numb_stack_cont[i]+\"/\"+str(i))\n",
    "            i = i + 1\n",
    "            \n",
    "        edge_list.append([operation_nodes[-1],placeholder_nodes2[-1]])\n",
    "        placeholder_nodes2[-1].inputs = [operation_nodes[-1]]\n",
    "        \n",
    "        for a in range (len(edge_list)):\n",
    "            if type(edge_list[a][0]) is str:\n",
    "                index = numb_stack_cont.index(edge_list[a][0])\n",
    "                edge_list[a][0] = placeholder_nodes2[index]\n",
    "\n",
    "        for my_node in variable_nodes2:\n",
    "            color_map.append(\"yellow\")\n",
    "        \n",
    "        i = 0\n",
    "        for my_node in placeholder_nodes2:\n",
    "            color_map.append(\"red\")\n",
    "            label_dict[my_node] = (\"P\" + \"/\" +  str(i))\n",
    "            i = i + 1\n",
    "        \n",
    "        for my_node in operation_nodes2:\n",
    "            color_map.append(\"lightblue\")\n",
    "        \n",
    "        return [node_list,edge_list,color_map,label_dict,placeholder_nodes2[-1]]\n",
    "    else:\n",
    "        # this else part is used for if the string has blanks. So it basically helps to understand every string without\n",
    "        # boundaries like need of the space after every character.\n",
    "        return math_operands_split(''.join(mat_op))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Forward Propogation Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Mapping the values according the input strings and data dictionary and then computing the forward propogation\n",
    "# according to the traversal list, computing the variables and assigning operation nodes to data dictionary.\n",
    "def forward_propogation(my_traversal):\n",
    "    while len(my_traversal) > 0:\n",
    "            my_node = my_traversal.pop()\n",
    "            if my_node.return_type()[0] == \"Placeholder\":\n",
    "                x = [data[number] for number in my_node.inputs]\n",
    "                my_node.change_value(x)\n",
    "                print(my_node.return_val())\n",
    "            else:\n",
    "                print(label_dict[my_node])\n",
    "                x = [data[number] for number in my_node.inputs]\n",
    "                print(x,\"mapped values\")\n",
    "                my_node.change_inp(x)\n",
    "                y = my_node.compute()\n",
    "                print(y,\"result\")\n",
    "                data[my_node] = y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Backward Propogation Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# In order to compute the derivative of the nodes according to it's inputs, we're using a simple approach like\n",
    "# Increasing it by 0.001 and subtracting that incremented value from the default computed one,\n",
    "# then dividing the result into 0.001. Which acting as a delay operator.\n",
    "def backward_propogation(my_traversal):\n",
    "    while len(my_traversal) > 0:\n",
    "        my_node = my_traversal.pop()\n",
    "        if my_node.return_type()[0] != 'Placeholder':\n",
    "            if my_node.return_type()[1] != \"Subtract\":\n",
    "                print(label_dict[my_node],\"my node\")\n",
    "                x = []\n",
    "                for inputs in my_node.inputs:\n",
    "                    print(data[inputs],\"inputs\")\n",
    "                    inputs_default = data[inputs]\n",
    "                    changed_input = inputs_default + 0.001\n",
    "                    x.append(changed_input)\n",
    "                i = 0\n",
    "                for number in my_node.inputs:\n",
    "                    my_node.change_inp([data[number],x[i-1]])\n",
    "                    y = my_node.compute()\n",
    "                    the_diff = y -data[my_node]\n",
    "                    print(round(the_diff/0.001),\"The Derivative\")\n",
    "                    i = i + 1\n",
    "            else:\n",
    "                print(label_dict[my_node],\"my node\")\n",
    "                x = []\n",
    "                for inputs in my_node.inputs:\n",
    "                    print(data[inputs],\"inputs\")\n",
    "                    inputs_default = data[inputs]\n",
    "                    changed_input = inputs_default + 0.001\n",
    "                    x.append(changed_input)\n",
    "                i = 0\n",
    "                for number in my_node.inputs:\n",
    "                    if i == 0:\n",
    "                        my_node.change_inp([data[number],x[i-1]])\n",
    "                        y = my_node.compute()\n",
    "                        the_diff = y - data[my_node]\n",
    "                        print(round(the_diff/0.001),\"The Derivative\")\n",
    "                        i = i + 1\n",
    "                    else:\n",
    "                        my_node.change_inp([x[i-1],data[number]])\n",
    "                        y = my_node.compute()\n",
    "                        the_diff = y - data[my_node]\n",
    "                        print(round(the_diff/0.001),\"The Derivative\")\n",
    "                        i = i + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# String\n",
    "\n",
    "- You don't have to put any closing parantheses for operations to be understood, but if you want to specify the operation order, then you need them. To check you can try (e + f) and e + f as stated below. Both will give different answers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# [node_list, edge_list,color_map,label_dict,reverse_start_node] = math_operands_split(\"a*(b + (c*d)) - e + f\")\n",
    "# data = {'a':5.0,'b':3.0,'c':2.0,'d':4.0,'e':5.0,'f':2.0}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "[node_list, edge_list,color_map,label_dict,reverse_start_node] = math_operands_split(\"a*(b + (c*d)) - (e + f)\")\n",
    "data = {'a':5.0,'b':3.0,'c':2.0,'d':4.0,'e':5.0,'f':2.0}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "G1 = draw_graph(node_list,edge_list,color_map,label_dict)\n",
    "G2 = draw_reverse_graph(node_list,edge_list,color_map,label_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Graphical Representation of the Equation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAd0AAAFACAYAAAD5xabzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3Xd4U3UXwPFvuicbCmVWhgIiUJasgkWGhbIE2VvAV5YylOFAFCdoERniAlEERIbsIQIyyt57F1A2lO6V+/7x66alaZv2Ju35PE8emuTem9PS5uQ3j0HTNA0hhBBC5DgbvQMQQggh8gtJukIIIUQukaQrhBBC5BJJukIIIUQukaQrhBBC5BJJukIIIUQukaQrhBBC5BJJukIIIUQukaQrhBBC5BJJukIIIUQukaQrhBBC5BJJukIIIUQukaQrhBBC5BJJukIIIUQukaQrhBBC5BJJukIIIUQukaQrhBBC5BJJukIIIUQukaQrhBBC5BJJukIIIUQusdM7ACGEyLsigBXAZmA3cC/+8eJAQ6AV0BFw0iU6kfsMmqZpegchhBB5SzgwGZgDGICQdI5zi39+BPAuknzzPkm6QghhVnuBl4H7qJauKZxRrd8VgHcOxSUsgSRdIYQwm82o7uLwLJ7vAqwDmpktImFZJOkKIYRZHEeN04Zl8zquwEHg6WxHJCyPJF0hhMi2GOBZ4DyQ3bdUm/hrHQJss3ktYWlkyZAQQmTbXOAG2U+4AEbgIvCTGa4lLI0kXSGEyBYN+Izk3cpnz0Lt2uDuDl9/nZVrhgGfYp4kLiyJJF0hhMiWvUBwikc+/xyaN4eQEBg5Uj1WpQqcOweTJ4O9Pbi5Jd0uXUrrujeBYzkauch9knSFECJb9qLGdJNcvQrVqyfdv3gRjEaVeAG6dYPQ0KTbU0+ldV0t/toiL5GkK4QQ2bILiEq85+sLf/8Nw4erVuy5c7B2Lfj5Zfa64ahdrEReIklXCCGy5U6Ke1u3QtOm8M03qhVbpQqsWwdt2yYds3o1FCmiWsNz5ph+bWH9ZO9lIYTIlie/jYaHw/790Cx+v4tXXoEhQ8DDA/buhZdfhkKFoEePzF9bWB9p6QohRLY8g9o/OW1//QWNGoFT/LbK1aqBpyfY2qrHR42CZcvSOtMGqJoD8Qo9SdIVQohsaYgqXJC21F3LqRkMkPYWRW5Ag2zGJiyNJF0hhMiW5qSevZzc+vUpJ1GtWgUPHqhEu2+fWsfboUNaZ0YBTc0bqtCdJF0hhMgWT9IrUHDihJrBXK5c0mOLF0OlSmrjjL594e23oV+/1GcagLZAsZwJWehG9l4WQohs24dq8aYs5ff553D3rvo3c5yBQOA5cwQnLIi0dIUQItvqA6+ikmWSChVgwIDMXssFeANJuHmTtHSFEMIsIoHGwEmSb5aROU5AbWAb4GCesIRFkZauEEKYhRMqWdZEtVYzR9NcgbrAZiTh5l2SdIUQwmzcUdtCTkR1NdtneIamORARYcPBg+1QSds1JwMUOpOkK4QQZmUHTEJ1M7+OWm+bcLNDJeKE++4YDCM5e3YF7dvvIDg4VKeYRW6RMV0hhMhRscAZ4BBwC7UcyAOoAzwN2AIwePBgXF1dCQgI0ClOkRsk6QohhAW4c+cO1atX56+//qJGjRp6hyNyiHQvCyGEBShevDiTJ09m2LBhSFso75KkK4QQFmLo0KGEhoby22+/6R2KyCHSvSyEEBZkz549dOnShdOnT1OgQAG9wxFmJklXCCEszIABAyhatCjTpk3TOxRhZpJ086SrwAZgJ2rZQgxQAFWCrCHwEllZvC+EyB23b9+mevXqbN++nWrVqukdjjAjSbp5yj7gbdRG6TZAeKrnDai1gUZgAPABUCQ3AxRCmGjmzJmsWLGCv/76C4PBoHc4wkxkIlWeEAWMQlU52YbaAzZ1wgXQgBAgDPgOqAiszpUIhRCZ87///Y979+6xdOlSvUMRZiQtXasXDrwIHCF1WTHTuAAfo5K2EMKS7Ny5kx49enD69Gnc3Nz0DkeYgSRdq6YBLVF7vUZm4zrOqJZvL3MEJYQwo759+1KqVCk+++wzvUMRZiBJ16rNAcahuouzyxW1VV0ZM1xLCGEuN2/epEaNGvzzzz8888wzeocjskmSrtW6B5Qj7bHbrLBDtZrXmel6QghzCQgIYO3atWzatEkmVVk5mUhltb5HdS8/rn9/eOedzF4vFvgbCMpWVEII8xs+fDg3b97kjz/+0DsUkU2SdK3WTEydOPXxxzBxIpw6BXXrQuHC6vbii+qxJEbghxyIVQiRHXZ2dnzzzTeMHj2asDBzDCcJvUjStUr3gDsmH71uHfj5gacnLFsG9+/D3bvQvj107578yGhgs5ljFUKYQ7NmzWjSpAlTp07VOxSRDZJ0rdJh1Izj+HuHwdsb3N2hWzeITDaR+cEDOHcOGjaEQoWgQgUwGEDTwNYWLlxIfe0TuRC/ECIrpk2bxrx58zh37pzeoYgskqRrle6iuoIhOho6doQ+fVQLtmtXSD7ss3EjtGihEmyCQoXAyQlGjFDdzimFkt5YsRBCX56enowfP56RI0dK+T8rJUnXKiXNXgwMhJgYeOMNsLeHLl2gXr2kI9euVV3LyT18CMHB8M03ULt2WteW2ZFCWKpRo0YRFBTEqlWr9A5FZIEkXatUmoTE+O+/ULq06jJOUL68+tdohM2boU2bx6/g6gqvvQZ9+8Lt28mfKZxTQQshzMDe3p5vvvmGN998k/Bwcy0ZFLlFkq5VqkXCzOVSpeDGDTVGmyAoftXP/v1qDLd48bSvYjRCeLg6P+W1hRCWzNfXl/r16/Ppp5/qHYrIJEm6VskNVaxATZCys4Ovv4bYWFi+HPbtU0el7lrevFlNuoqLg0ePYPRotXSoatWEI1wA/1z8PoQQWTV9+nRmz57NxYsX9Q5FZIIkXav1FuCGg4NKtPPnqwS6ZAl07qyOSFgqlODhQ+jRAwoWhIoV1czlDRvUpCrFCPTN1e9CCJE1ZcqUYdy4cYwaJcVKrIlsA2m1woGywP00n711C2rVUmO+pu0a5wT0AeaZLUIhRM6Kjo7mueee44svvsDfX3qprIG0dK2WC/BL/L+PCw6GL780NeECuAPTzROaECJXODg4MHPmTEaNGkVERFZKe4rcJi1dqzcc+InsFT5wBjYBTcwSkRAid3Xp0oUaNWrw/vvv6x2KyIAkXatnBIYCi8hs4o2LAxsbFwyGFUCrHIhNCJEbgoKCqF27NgcOHMDLy0vvcMQTSPey1bNBjcPORc1qdjDxPFf+/bcQU6a0RxKuENatXLlyjB49mjfeeEPvUEQGJOnmCQbUJKjzwBtAgfibc6pj3FFjwNWA2RQocJGfftrD+vXrczleIYS5jR07llOnTrFundTEtmTSvZwnRQOHgIOoAgZRQBGgDlAPqJR45N9//03v3r05duwYRYsW1SFWIYS5rF+/nhEjRnDixAmcktYCCgsiSVcwZswYgoKCWLp0KQbTpzsLISxQx44dqVevHpMmTdI7FJEGSbqCyMhI6taty/jx4+ndu7fe4QghsuHKlSvUrVuXgwcPUj5hI3ZhMSTpCgAOHz5M69atOXDgAOXKldM7HCFENkyZMoWjR4/yR/I6n8IiSNIViT799FM2bdrEli1bsLGROXZCWKvIyEiqV6/OnDlzaNVKVidYEnlnFYnGjRtHdHQ0AQEBeocihMgGJycnZsyYwYgRI4iKitI7HJGMtHRFCpcuXaJBgwZs27aN6tWr6x2OECIb/P39ady4MePHj9c7FBFPkq54zPfff8+sWbPYu3cvDg6mbrYhhLA0ly5don79+hw+fJiyZcvqHY5Akq5Ig6ZpdOjQgWeffZaPP/5Y73CEENnw/vvvc/r0aZYuXap3KAJJuiIdt27dolatWixbtozGjRvrHY4QIosiIiKoVq0a3333HS+++KLe4eR7MpFKpMnDw4O5c+fSt29fQkJC9A5HCJFFzs7OfPXVV4wYMYLo6Gi9w8n3pKUrnmjQoEHY2Njw3Xff6R2KECKLNE3Dz8+PFi1aMHbsWL3Dydck6YonCgkJoWbNmsyYMQN/f3+9wxFCZNH58+dp2LAhx44dw9PTU+9w8i1JuiJD//zzD926dePo0aMUL15c73CEEFk0adIkLl++zKJFi/QOJd+SpCtMMn78eM6ePcvy5culKIIQViosLIxq1aqxYMECmjdvrnc4+ZJMpBIm+eCDD7h06RLz58/XOxQhRBa5urry5ZdfMnz4cGJiYvQOJ1+Slq4w2fHjx/H19WXfvn14eXnpHY7I9yKBdcCu+NsDwBZ4CmgOtARq6hWcxdI0jdatW/PSSy/x5ptv6h1OviNJV2TK9OnTWbVqFX///Te2trZ6hyPypVDgA+DbZPdTv405AHaoBPwxIJMAkzt79ixNmjTh2LFjlCpVSu9w8hVJuiJTjEYjvr6++Pn58dZbb+kdjsh3tgHdgWBUS9cULkBr4AegcM6EZYXGjx/PjRs3WLhwod6h5CuSdEWmXb16lbp167JlyxZq1pTuO5FbFgGvAhFZONcB8AQCAQ9zBmW1QkNDqVq1KosWLaJp06Z6h5NvyEQqkWnly5dn2rRp9OnTh8hIU1sbQmTHFrKecAGigetAU0xvIedtbm5uTJ8+nWHDhhEbG6t3OPmGJF2RJX379qVy5cq8++67eoci8ryHqC7lrCbcBLGoxDsh2xHlFV27dqV48eLMnj2b+/fvy/rdXCDdyyLL7t69y3PPPcdvv/1Gs2bN9A5H5FmvAQswXwvVGdgPSL1oUKsSGjZsiMFgICwsjKioKOzt7fUOK8+Slq7IsmLFivHdd9/Rr18/goOD9Q5H5EkhwM+Yt0s4GvjSjNezXpcuXeKVV14hOjqa0NBQHB0duX//vt5h5WmSdEW2tG3bljZt2jBq1Ci9QxF50jIy8zbVqhVs2pTyMV9fMBggadgyDvgNlXzzt0ePHnH79m1sbNTP2MbGhrt37+ocVd4mSVdk27Rp09i5cyfLly/XOxSR52wBwkw6MiwMDh6E5CMdv/6aPNkmZwecMEN81q1WrVpcvnyZnj174uDgQEREBLdv31ZP3roFf/wB48ZBp07QoQO89hrMnw9nz+oatzWTMV1hFnv27KFTp04cOXKEkiVL6h2OyDMqAxcS7/37L4wYATt2gJsbvPkmjBypnvvzT/j+e/UvQHAw1KsHP/8MDRtCTAzY2SVcyRUIQM2IFgA7d+7Ez8+PJaNH89L+/bB1K9jbq08zRmPSga6uoGlQqRJMmgRdu6quBGESaekKs2jYsCGvvvoqgwYNQj7HCfN5mPiV0Qj+/lCzJty4AX/9BQEBsHGjen7dOmjbNunMiRPhf/+DtD8DRgH3cjJwq9PE25tHvXvz0uefw/r1EBkJISEpEy6oJBweDseOwcCBqmvh+nV9grZCknSF2bz33nvcvHlTCt4LM0pqQe3fD3fuwHvvgYMDPPUUDB4Mixer59evBz8/9fWBA7Brl2oVp0/e/hLdvw/166uu44gI1ZI1RVgY7NkDNWrA0aM5GmJeYZfxIUKYxsHBgYULF+Lj44Ovry/FihXj5MmTNG7cWO/QhNUqBdwB4OpV1b1cqFDSs3Fx0LQpHD8OBQpA2bKqYfb66zBjRvLu5NScgTI5HLuViIpSrdXz5yE6C5PLYmPh4UN1jUOH1KchkS5JusKsqlWrxrvvvkuHDh24desWmqZx755044msagIcA1RC9fJSuSG1zz5L6lp+9Ei1dLt1U/fj4tS/ZcrA77+rJA1GoE4Ox24lJk6ES5eylnCTCwlR47v794ON9CKkR34ywqwiIyM5c+YMZ86c4d69ezx69Ijw8HC9wxJWqzXgDqjezwIFVIKNiFDJ9MQJ9R6/dm1S13LBgqpFfOSIuq1bpx4/eBAaNEi4rgNQKZe/Fwt07BjMmaPGaLPLaFSzmr/9NuNj8zFJusKstm7dyty5czHGT75wcHDgwoULjx9oNEJoqBoTkolXIl1+qAQJtrawerVKpF5eUKwYvPqqSrCnT0OjRuoMg0FNnkq4FS+uHvfwUGPB4ASMQN7+UJ9goqLMd72wMPjoI/mbfgL5rctQJLAXmANMAT5ElQg7AsToGJdl8vPz48CBA9SrVw9HR0fCw8M5efKkevLCBRg7Fp57DlxcoHBhdXN2htq1YcIENXAnRCI71F7JrgB4esJvv8HNm/DgAQQGqpzxwgvpj99WqKByQNLztsDrOR65xQsJgeXLE2cnV0CNdLuh6jANQFUqBrWNSLH4+/1RH4Pckt3ikl/30SPYvj3Hw7dWknTTdRL161UYaAWMAd6Pv40EfIAiwBvAFV0itFR16tRh7969LF++HHd3d05t2AAvvqhmOH79tZr1EhWlJmDExKivjxyBL7+EZ55Rg3P//af3tyEsxhuAF+m9XRUqpNbrmsYVmIGU90P1tzs6pnhoNSqxHkLtTv1R/OM7gFqoBAvwVvxxCTfb5BeJjJSk+wSSdB8TCYwG6gG/xN9/RFKFEw0IR+0JGwrMBqoBn5Pq816+ZjAY8PPzI3jWLKb88Yf6I4yMVEk2PdHR6pjNm+Hpp9WncCGwBVaQMLabWqtWavOLjDmjPkAPNFtkVu3gQTU4nobSwEsk7dm1DtXRb5LYWNi2LbvR5VmSdFO4C9QGvkUlWVOSaEz8sR8ALVAJWQAwcyaG117DEBaW3l58aYuJUV1fvXurdYNCUAnV3ioMZKUCjivQElhC8rW/+dq1a+nOWL6GSrS14++vA5LtO8JsVD9fHeCPtC4gPVXpkqSb6BHQCLhI1hJnOGrstw0y1ovaJujtt7M3KzIiQi243LXLfHEJK/YccApoTsIYb0aio8FodAY+Q7WWpWRdojQmO3UECqEWajUDJgKXUO9oT8cfMxI4D9xGzXDpDzz2FyoTqdIlSTfR/4AgspcwI4GDwMdmichqBQdDr17pdl1lSkQEvPKKeZY0iDygJLAR+B01r8IRKEDKUUXn+Mfc2Lu3Du+/3xUYhrzdpVK6dMJ07kQrURtvXkW1Zp2BtaTsWvYGiqKmuPkBvYDHBoJk//V0yW8hoCqZrETtx5pd4ahP1afNcC0r9emnaumAuTx4ADNnmu96wsoZUCOO21GTGH8B3kMl1jdQ8ys2AnepUmUts2at5saNGzrFasHq1AEnpwwPS921nJoBNdMlka0t+PhkL7Y8TKoMAfA8qmvYXGyBHsBCM17TSkRHQ4kSqrWLWoZwC/UTcUV9Mp6JmgUZDXii3janoCqcBqNG7YYAk5Jft0QJNU4kO92ITBo9ejRGo5GAgAC9Q7EswcFq8XL8Ot0KwPfAi8kOiUBtlnkDtboZVIXjNoALqrnyMmrWc/OEk9zd1STIF5NfSSSQdzDOk7DNnCmGDIF589QOOE2aqOUKJUuqjddDQhKOikP9agabP1xLt23bY+M5pixDGAScQY2s7wYWkarLKiIC9przg5HIL8aNG8fPP//MzZs39Q7FshQsCO3aPfGD7F9AQ5ISLqgFV6VRY7/jgO9IlnBBrbv39TV3tHmGJF3+ytTRGzao7eaCg+Gdd5J2w7l+XdV6TuIABJozUOuwb1+6469PWobwNCmnxtiQvIoqakbzgQNmDVXkD6VKlaJ3795MmzZN71Asz4QJiWt1r5CylQtpLxX6B9WceAQcBbonf9LFRU2glB6pdMlPhn9IWoOrXLsGnTur7eOKFoXhw9Xjx46plm2ZMtCzJ7Rpk7Sx0uDBqSfZhgP5MEkEBqa7PCijZQifolq9ZYAwoGfykyMjpaUrsuytt97ixx9/5Pbt23qHYlnq1IF+/TCmM7ZbC+hk6rUMBrU/58iR5oouT5Kky8UU9+LiVI9L+fJw5Yoqlt09/qNc6iLZye3YAdWrJ38kFtVhms88evTYQ6YsQwAYj9py5BDQByiY+kLB+bC7XphFmTJl6N69O19++aXeoVicw717cyUmhrg0WqdDUMUVTeLqCsuWPameokCSLio5Jtm3T3UZf/GF+h1yclJjt5CykklymzfDggUwZUrqZ4w5ErFFS7WtHJi2DCGBAdUSdkZtuJmCCTMthUjP+PHjmTdvHnfv3tU7FIuxYcMGWnXsyOl587CtUCHNv98M2dioyVNbtqhtXMUTSdKleIp7166pVm7qD2sPH8KZM0mVTBIEBqqu5mXLoEqV5M8YgBI5EbBlq1XLpPGcjJYhxJKqD8LeXl1biCwqV64cXbp0kVnM8X788Uf69+/PypUraTtwoCpA//LLaszMVK6uULOmOjepbqJ4Akm6NEEt81bKloWgoMeHJTduhBYt1BK0BIcPQ/v28OOP6rmU3ID6ORSzBWvQQP0hPkEEsI+kGY9G1MabD1Dr/fYBs1CbaiZydoa6dc0crMhvJkyYwJw5c3jw4IHeoehG0zQ++OADPvroI7Zv307jxo3VEwULwq+/qvqJjRurnqW0/pYTHvfygoAANcGxktQmNpWs02UratRRrfeJiwNvb2jZEj74QCXZgwdVXeYXX4S+fdVZJ06oRPv119CtW1rXdUbN030qV74Li/Hggaq/FhkJpL32bw0wN/5fUEnXD5VsE9bu9kcVdEvcJdfFBW7fzjChC5GRgQMHUq5cOSZPnqx3KLkuJiaG//3vfxw5coQ1a9ZQ8kk7R126pAqV7NoFFy+qEoAeHtC0qaowUaeOmjwlMkWSLnGoqQJ3Eh8JClIT8P75R/1O9eihuo+PHlV7NAAMGKDGcZP3xJQvDwmlY8+cceHQoe/o0qULDqm2WsvzevaEpUvVJ5g0vA48SyYqmtrbq2rls2ebKUCRn124cIHnn3+eixcvUrDgY9P18qzQ0FBeeeUVAJYuXYqbm1sGZ4icIN3L2KJq5SZlz3LlYOVKuHcP7t6FPn1Ut3OJZEO0P/2kPviFhibdEhKuprny6NFwvv/+e7y8vJg6dSp37twh35gy5bE9XZPL1DIEUNeaODG7UQkBQKVKlfDz82NmPtpa9ObNmzRr1ozSpUvz559/SsLVkSRdQO3X+uSi1h98YOq17DAYvKlf/1O2bt3K+vXruXTpElWqVGHQoEEcO2b67ldWq1Il+PDDdCdkZGoZgosLfPWVWhwthJlMmjSJGTNmEJK0jVyedfbsWRo1akSHDh2YN28edrKkR1fSvZzoMGpSVXar2RQEjgNlUzx6584d5s2bx+zZs6lSpQqjRo3C398f2+Qzs/ISo1FVB1q/PusVglxc1DV+/FHGjoTZ9ezZkxo1ajBhwgS9Q8kxu3bt4uWXX+aTTz5hwIABeocjkKSbygbU9t1ZSRIGwB34G1X8Km3R0dH88ccfzJgxg9u3bzNixAgGDhyYN8eWYmNh0CA1IJ7JxBthMGA/ZAh2s2fLlnIiR5w8eRJfX18uXryYJ7tbly9fzmuvvcbChQtp3bq13uGIePJulkIb1Gzm0qjZx6ZyAaqhtvNPP+ECODg40KNHDwIDA1m0aBH79u3Dy8uLESNGcO7cuawGbpns7NRss99+U3tlmvLG5uaGVqwY0xo35i0XF0m4IsdUr16dZs2aMXfuXL1DMbuZM2cyYsQINmzYIAnX0mgiDeGapr2taZp7/I00bob454ppmjZN07SYLL/a9evXtYkTJ2rFixfX/Pz8tI0bN2pGozF734KlCQ/XtPnzNe3ZZzXN3l7TChTQtIIF1c3dXT1Wu7am/fqrpkVGanfv3tXKlCmjbdq0Se/IRR529OhRzcPDQwsLC9M7FLOIi4vTxo4dqz3zzDPa5cuX9Q5HpEG6l58oCvgT1frdDdxFdSOXBJqiVp+2Qc2Azr6IiAgWLVrEjBkziIuLY+TIkfTp0weXzOwQYw2iouD4cbXu1mBQa/+effaxGc9btmyhf//+HD16lKJFi+oUrMjrOnfujI+PD2+88YbeoWRLVFQU/fr148aNG6xatYoiRYroHZJIgyRdC6RpGtu2bSMgIIDdu3czcOBAhg0bRrly5fQOLdeNGTOGK1eusGzZMgwymUrkgMOHD9O2bVsuXryIs3NmhpUsx4MHD+jUqRPFihXjl19+wUn2KbdYMmBmgQwGAy+88AKrVq0iMDCQ6OhoateuTdeuXdm5cyf56XPS1KlTOX/+PPPnz9c7FJFH1a5dm7p16/LDDz/oHUqWBAUF0bRpU2rXrs3SpUsl4Vo4aelaiZCQEObPn8/XX39NwYIFGTVqFK+88gqOWakKYmVOnDjBCy+8QGBgIBUrVtQ7HJEH7d+/n86dO3PhwgWr+ps6evQo7dq1Y/To0bz55pt6hyNMIEnXyhiNRtavX09AQAAnTpzgtdde47XXXsPD48mbe2RaTIwadz14UBUVNhqheHGoXVvdcnkP5BkzZrB48WL++ecfWdwvcoSfnx/t27fntdde0zsUk2zZsoWePXsya9Ysunbtqnc4wlR6zeAS2XfixAltyJAhWqFChbS+fftqBw8ezP5Fr1zRtDfeUDOK3d01zdVV00DdnJzUrGMnJ03r3l3TDh3K/uuZKC4uTmvZsqU2efLkXHtNkb/s3r1bK1++vBYVFaV3KGnauXOndu/ePU3TNO3nn3/WSpQooe3YsUPnqERmSUs3D7h37x7ff/8933zzDV5eXowaNYoOHTpkrkVoNKoyXe++qza1iI5+8vE2NqrEV9++MH165mpwZtG///6Lt7c3K1eu5Pnnn8/x1xP5T6tWrejWrRuDBg3K0deJiTMSHBVLdJwRgwGc7Wwp4GiHTTqTBSMiIihWrBiVK1emU6dO/PTTT6xbt45q1arlaJzC/CTp5iExMTGsWLGCGTNmcP36dYYPH86rr75K4cKFAVixYgXOzs60adMm5YkREeDvD4GBEBaWuRd1doaSJWHnTlXSL4ctX76ct956i8OHD+Pu7p7jryfyl507d9K3b1/Onj2Lvb29Wa8dHWfkanA4Fx6EERlrxNYmZYKNM2oUcrKnShFXSrk5pUjACxYsYNiwYURGRuLi4sLJkycpW7Zs6pcQVkCSbh514MABZsyYwZo1a+jevTuvv/46vr6+hIaGsmvXLry943fOiouDVq1gzx6VfLPCzk4l3MOHIRfWBia0Qqx1tqmqIHweOAQX4GPDAAAgAElEQVTcRK399gDqAJWQRQX68vX1pV+/fvTr188s19M0jcsPwzl+JwTQiMvgHdfOYMDO1kADz8IUdVZr16tXr86pU6cAtavd4MGD+eabb8wSn8hdknTzuP/++4+5c+cSEBBAWFgYcXFxFC1alGPHjuHp6QmffqoqAmW1KEECBwd46SVVEzGHhYaGUqtWLT7//HM6d+6c469nPteAb4C5qDrONqgNWAAcUcnYDngNGA5IZSU9bNu2jSFDhnDq1KlsT9qLNRrZff0BDyJjiMvkW62tAaoUcePO6SM08/HBzs4OW1tbSpYsyaBBg3j33XezFZvQhyTdfKJmzZopygp6eHhwfv163Bs3znoLNzUXF1i8WHVV57DAwEA6dOjAoUOHKF26dI6/XvbEAV8B7wOxQAbj5Tiidjn7CBiFtHxzl6ZpNGvWjKFDh9KrV68sXyfOqLHj2j2Co2IwZvFd1tZgIPz6Rb4YO4LRo0fz4osvUrJkySzHJPQnSTcfePToEcWLF8dgMODs7IydnR0xMTEcb9iQslu2qIlT5vLcc3D0qPmu9wQffPABu3btYsOGDdhYbGGEMNRWoYfjv84MV6AusA5VVEPkli1btjBixAhOnDiR5fKbh28Gc/VReJYTbgJbAzTwLExJN9n0Ii+w1HcqYUYFChQgMjKSyMhIHjx4wJ07d3h44wZlt29PTLgVUHWV3FCjiwOA0Pjzo4Fi8ffHApVRRQyfAX5O/WIXLkCyFnVOmjRpEqGhoXz99de58nqZFwW0AA6Q+YRL/Dl7gVZk3DoW5tSiRQsKFy7MsmXLsnT+3fBogsyQcAHiNNj/30Ni4ozZv5jQnSTdfOKxfYsPHHiswMBqVGI9hCpS+FH84zuAWqiE7Bp/XDCwANX5uTv5ReLiYOtWc4efJjs7OxYuXMjUqVM5fvx4rrxm5rwDHAcis3GNSFQrebI5AhImMhgMvPfee3z44YcYjZlPdsfvPMpwwlRmxGkalx5mc96FsAiSdPOrgwchMu1kUBp4CTgRf38d4Bf/9QeoFq4N0ABVa2lP8pOjomD79hwIOG0VK1bk888/p1evXkSm8/3o4zAwCzDHG2U4EADkTg+CUFq3bo2LiwsrVqzI1Hkh0bEER8WYfPz9WzcZ3KwOMdFRzJo0mqG+9ejlXZmxnVpyaIf6AGvU4MKDsHy173peJUk3vzp/XiXINFxDJdra8ffXAW3TOC4C1SKunvqJixfNE6OJ+vfvT5UqVZg4cWKuvu6TvUf2WripRaI+8ojcktDanTJlCkajkSNHjhBmwjr2m6GRkCo3Lpk5jSUzp6V5/KEdf1G7aXPiYuMoVtKTD39ezsIDZ+k+8i2mvzGU29evARBr1AiJNuP8C6ELSbr5VRqTpzoChYAmQDNgInAJiAGeTuMSrwE1gdapn8hCd1x2GAwGvv32W5YuXcrmzZtz9bXTdgvYwmPvvOkYMgTmzVNfL1oE5curra07doT79xOO0lAff+6aPVqRvrZt2xIeHs4zzzxD7dq1Tfr9uhseTWb+Ag7t2Iq3TwucXFzoNmIsJcqUxcbGhrovtKREmXJcPJnUw/Eg0vQWtLBMknTzKw8PtZVjMiuBh8BVYDZqYtVakrqWkxuH6n5eitraIQUdCs4XLVqUn376iQEDBnDv3r1cf/2UtgGm72a0YQP4+cHJkzB0KCxcCLduqRVYr7+e/EgHIPe67vO7O3fuULduXa5du8b58+dN3gEtM63R2JgYTu0PpGYjn8eee3j3Dv9duUTZylUANa4bKi1dqydJN7+qWxfc3DI8LK2u5feB9cAmoEDqE2xtoWlTc0SYaS1btuSVV15h6NChOo99BZI091vtP1KxIri7Q7VqkHyI8NgxKFQIypSBX39VS5x9fNR/zYcfwvLlEBKScHQoajazyA1OTk4YDIbEJUNxcXEmLU3LzIzlUwcCqfBMdZxT/S3GxsQQMG4YzTt2pcxTlRMfN+fkLKEPSbr5Vf36GRY1iAD2Ac2TPfYJsAjYDKTZnnV1hcaNzRNjFnz88cecO3dO56L3p0netVyxIvzzDwQHw/vvQ+/e8N9/6rl166Bt/KeakyehZk1SnOfgAOfOJTxijL+2yA3u7u4EBgYydOhQHBwciEhvE5lUH/Ds4vdU/nhoX/rUe4Y+9Z5hxXezWPHdrMT7Hw/tC8Ch7Vvx9vFNcb7RaOTrt0dgZ+/Aq+9OTfGcvU3aBRGE9ZCkm195eqrW7hP8BTQEki/JnwgEodbqusXfPk72vGZnBy1bmjfWTHBycuLXX3/lrbfe4mIuT+hKkrILsGtX9eO2sYFu3aByZdi3Tz23dq3qWgYIDYWCBVNeqWDB5C1dUCPsIrfY2dnx5Zdf8vvvv2MwGLgbFAQ//gjt2kGpUqpnx8ZGjQV4e8OYMRSKVJOtJn77Mwv3n2Hh/jN0GjyMToOHJd6f+K1a4X5ox194N2+R+HqapjF70mge3r3LuK+/wy5Z0QU7g4GCjuYtwiByn1QDz88mTlQZISyMK2k8nXypUIIn9W5F2tjwvY0NZdeupX379o+vDc4lNWrUYNKkSfTp04cdO3boUPS+WIp7P/8MX34JV66o+6GhcPcuPHwIZ85Ao0bqcTc3ePQo5ZUePVLd0klyf7xcQPs2bQh5802c335bJdnQ0JQHRESogh/Hj1Psxm1uTPiAOCfnJ17z1vUgYqKjU3Qfz5s8nuuXLvD+j0twTHW+EY3CTpJ0rZ20dPOzNm3U+Gs6JcxqAZ0ycTnH0qWpOG8e7777Lk2aNOGff/4xS5hZMXLkSNzc3Jg6dWrGB5tdIxL6B65ehcGD4Ztv4N49lWiffVb1SG7cCC1aqMYSQPXqKXfQvHRJreqqUiXhEWdAv677fOv0aahWDZc5czCEhz+ecJOLjcVzwxo0Ez5wHty2JUXX8u0b19m0ZCFXTp/k1aY16eVdiV7eldixejkA7g52ONtnbUtKYTmkpZufGQwwf76a3fPgwWNjU0Mycy0XFwzLlvFS/fq0at+eRYsW0bdvX6pXr87HH3/Mc889Z87IM2RjY8P8+fOpXbs2rVu3zuWi9w1I+NMKC1M/5uLF1TM//QQn4ncdSd61DNCrFzRsqMZ/vb3hvfegc+fkLV3b+GuLXHP0qJrZFhLy2N9HehyCH+K5eT03WrdDi/9A223E2MeOO7RjKy/1GpB4v0TpMvxx5t80r2lrMPB0kYwnPgrLJy3d/M7DA3bsUFNos1o0wMUFlixRk7MAW1tb+vTpw5kzZ2jZsiWtWrWiT58+XL582YyBZ8zT05M5c+bQu3dvQlIOjOaw+oAanK1WDcaMUcnUwwOOH1fzzDQNNm9WnQ0JqleHuXNV8i1RQr3Pz56d/LpFAe9c/D7yubt3wddX9fFncjZ8jc8/xCY67c1nEjxbvyHPNmhk0vXcHGwp7S4FD/ICqTIklMuXoUsXOHtWNc9M4eyskvWyZUkDk2kICQlh+vTpzJw5k969ezNp0iRKlChhpsAzpk/R+5nAeNLbBnLfPhg+PGlCVcZcgS+A/5klOmGC9u3VGEAGs/zTc7VjV4689wlxLtmrEGVrMNCiQjHcHKRjMi+Qlq5QvLxg/361qNTDQ/VpptfydXdXt+HDVVWhJyRcdbg7kydP5vTp02iaRtWqVZk8eXKutT4DAgLYvn07y5cvz5XXU15DFaFPf2zvA5N3dTQA5YDB2Y5KmGjnTlW4I4sJF6D8yt+p+PN32IZnff9tW4OBhqULS8LNQ6SlKx5nNMKWLeq2Ywf8+6/qXitSRPWNNm+uWgFOWevuunTpEu+//z6bN29m4sSJDB06FEdHR/N+D6kEBgbSsWNHDh06hKenZ46+VpJjqElVWSnrl5wLasX0Y7tci5zSoQOsXp3pbuW0XOgziJOjJxLn4JA0ay4DNga13rehZxGKujhkfIKwGpJ0hW6OHj3KxIkTOXXqFB9++CE9e/bM0WL0+hS93wh0JqvVhqKi7HB0XA+8aM6gxJNERKhhk/hWbgXUbtq2qE5+P9TggRuqyrEncCX+PsB91F7lTwM74x8L8arIwU8CCH62JkY7u3SX3kVHRuLg6ED5gq48V6IA9rbSGZnXyP+o0E3NmjVZu3YtCxYsYNasWdSuXZu1a9fm2BaOkyZNIiQkhJkzZ+bI9dPWGlX8oBRqyY+pnDEaS9G3bxlmzTqbM6GJtB09+lgvjim1phO8DVRNdUn3yxdp3t2fF754n6cKu1DAwS7Fm6+djYEizvY8uniSTTM/oU6pQpJw8ypNCAtgNBq1FStWaFWrVtWaNm2q7d69O0de58KFC1qxYsW0Y8eO5cj10xemadpoTdNcNU1z0zSNdG5u8ceM0TQtTLtw4YLm4eGhbdq0KZfjzce+/VbTXFw0TXUua+VB2xz/tQbaWNDaxn/9JmjTkz23G7TnQfsRtMbJHk+8eXomvozRaNRi44xanNGY+Nh///2nFSpUSAsNDdXjOxe5QD5KCYtgMBjo2LEjx44do3///nTr1o2OHTty6tQps76OfkXvXYDpwG1UcfteQEVUMcXC8V/3RtV3ugNMA1yoWLEiS5cupVevXpw5cyYX483HQkIgJu3tNp9UazoOGAZ8wxOmzyVbGWAwGLC1MWCTbCONkiVL0qRJE5YtW5aNb0BYMkm6wqLY2dkxcOBAzp49S9OmTWnevDkDBgwgKCjIbK/Rv39/KleuzKRJk8x2TdO5AH2BX4ALwAPUKOAFYCHQh9Td0D4+Pnz22Wf4+/tbQNnCfMDe/rGZ+6bUmv4atXVJnSdd24QtSQcMGMBPP/2U2aiFlZCkKyySs7MzY8aM4dy5c3h6elK7dm3GjBljlqRjMBiYN28eS5YsYcuWLWaINucNGDCATp068fLLLxOdjWUswgSVKj02pptRrel/UUk3w01HvbwyfPl27dpx6tQpLl26lKmwhXWQpCssWqFChZg6dSonTpwgIiKCp59+mqlTpxJm6gYe6Uhe9P7+/ftmijZnffLJJxQsWJBhw4bpXC84j6tTB0wYekjetbwP+A+oBpQERsU/VhLV7Qyo/UB9Hi9Wn5qDgwM9e/bUuTylyCmSdIVVKFWqFLNnzyYwMJDjx49TuXJlZs+eTUw6Y2+maNmyJV26dLGAovemsbW15ZdffmHfvn0EBAToHU7e5eEB5cs/8ZDUtaZfQi0bOhJ/m4Ia9z2CWmoEqFrT7dubFMKAAQNYsGABRqMxc7ELiydJV1iVSpUqsXjxYlavXs2qVauoWrUqv/32W5bfnD755BPOnj3LggULANi3b59Fv9G5u7vz559/8sUXX7B27Vq9w8m73n5b1VpMR+pa046oVm3CrSBgH/91oqJFTWrpglpOV7RoUbZu3Zrp0IVlk80xhFXbunUr48ePJzY2lk8++YRWrVpluo7v8ePHad68OfXr12fDhg3s3LmTxo0tu4Tenj17aN++PVu3bqVGjRp6h5P3RESosd1/06768zrwbPy/JnFxUSWmXnnF5BBmzpxJYGAgv/76q8nnCMsnLV1h1Xx9fdm7dy8TJ05k5MiRtGjRgn2mVxEAIDg4mOjoaDZu3IizszNnz1r+ZhQNGzYkICCA9u3bc/v2bb3DyXucnVXlLOe0NzTJVK1pBwdo1gy6ds1UCD179mTt2rU8fPgwU+cJyyZJV1g9g8FAly5dOHnyJD169KBz58506dLFpHWtMTEx+Pn5ER4ejqZpREREcCKh4G0qcUaNmDgjRgvpHOrVqxe9e/emU6dOubzmOJ9o0gQmT1at1FSGoPYYy5C9PZQuDb/8oiZSZULRokVp2bIlS5YsydR5wrJJ97LIc8LDw5k5cybTpk2jY8eOTJ48mdKlS6d7fFBQEG+//TYrV64kMjISb29vDh48SJxR40ZoJEHB4TyMiiE6TsMAaICTnQ2FneypUNCFkq6Ome7SNhej0Ui3bt1wdnZmwYIFusWRp02fDu++q7qcM8PFBSpUgG3boHjxLL30unXrmDJlCoGBgVk6X1geSboiz3rw4AGffvop33//Pa+++irjx4+ncOHCANy6dQtN0yhZMmmqy8mTJ+nZsydXr17lwOXrnLobChrEPuFPxM5gwMYGankUpIx7ZvZWNp/w8HB8fHx4+eWXmTBhgi4x5Hn796vx2Hv31I5VT+LoqDbXGDtWJWt7+yy/bGxsLOXLl2fLli1UrZp6R2dhjSTpijzv+vXrTJkyhRUrVjBmzBhGjhyJr68vd+7c4eTJkzgl2wghMjaO3dfvExIdR1wm/jRsDVDcxZH6noWwy7UKRklu3LjB888/z4wZM+jcuXOuv36+EBMDf/4Jn38Ohw8njfdqmkqykZFqxvPgwfD661C2rFledvz48RiNRj7//HOzXE/oS5KuyDfOnDnDO++8w7Zt2wgJCcHW1pb+/fsze/ZsACJi4/j76l2iYo3pll57EhsDuDvY0axcUV0S78GDB2nTpg0bN27E29s7118/X4mMhOPH4fJliItTpQBr1YJSJo30ZsrZs2dp3rw5165dw86EbSSFZZOkK/IVo9GIl5dX4l7ODg4OrFq1ilatW/PXlTuERsdlKeEmsDFAMWcHGpcposv46rJlyxg9ejR79+6lVA4kAKGPRo0aMXHiRNq1a6d3KCKbZPayyFe2bdtGUFAQBQsWxNXVlZiYGPz9/Tl5K5jwmOwlXACjBvciYrj2KJOTbsykS5cuDBkyhA4dOhCR2Yk/wmJJEYS8Q1q6Il+JiYnh8OHDREZGEhUVRWRkJNf+/Q/PF/wxmvEvwd7GQNtKHinKtuUWTdPo3bs3sbGxLF68WGY05wGPHj2iXLlyXLhwgWLFiukdjsgGaemKfMXe3p769evj4+NDy5Yt8ff3x7dLj8fqn25dvoQTe3eneOzMof1M7O4PwO3r13ivbxd61HqKES815ejuHSmO1TT4N1SftbMGg4EffviBoKAgPvjgA11iEOZVoEAB/P39ZXeqPECSrsj3rgRHEBffyt20eCF7N68HVItx05JfEu8f2rEV72YtAPhqzOt4VX2W+YEn6fnGeKaNGkLw/aSyg7GaxuWH4bn7jSTj5OTEypUrmT9/PosXL9YtDmE+0sWcN0jSFflanFEjIiax+Bq+L3fnZtAV1v78HYu++hQbGwP1WrQG4NCOv/D28eXfyxe5dOo43UeMxdHJmYat21K+yjMEbkpZgOBhZNYrIJmDh4cHf/75JyNGjGDv3r26xiKyr3nz5gQHB3P48GG9QxHZIEk3z7gDTANaAMUAO1Sdk+JAS+ArIPsF4POaR9Gx2Nqk7FxOGAM1GMDGxhaDwcCD27cIvnsXr2o1uHbhHB5ly+GcrApN+aerce18yj2bY40a0XH6Vix67rnn+PHHH+ncuTPXrl3TNRaRPTY2NvTr109au1ZOFn1ZvXvASGA5YEBV+kzuLrAF2AVMBF4BAoDCuRij5YpLNXtq6x+LKVGmHG37Dqa4Zxn+u3KJfX9tIOThA2o1bY7BYCAiPAwX9wIpznNxL8D9WzdTPGZjUInXwRZd+fv7c/bsWfz9/dm5cyduTyhZJyxbv379qF+/Pl988QWOjo56hyOyQFq6Vm0DUAlYBkTyeMJNLiL+mCVARVQiFqkaubTq3ofnW/kBqsXbqnsfGrz4Eoe2b8XbR43nOru4EhGacivAiNAQnF1dUzympXF9vYwZMwZvb2/69Olj0fWCxZN5eXlRo0YNVq9erXcoIosk6VqtJUBn4CEQnYnzooAHQHtU6zh/c3Owe6y1C+DbuRvPNmgEQGxMDKf276FmY1WAvGylKty6FkREaGji8VfOnqJs5adTXMMAONpaxp+YwWBg7ty53L9/n0mTJukdjsgGmVBl3SzjHUFkUiAwkCe3bDMSAfQBDpglImvlYGuDQwaJ8fTBvZR/uhoubu4AeHpVpELV6iydNZ3oqEj2bl7P1bOneb5V2xTnuTvYWdQaWQcHB/744w+WLl3KggUL9A5HZFHnzp3ZvXs3//77r96hiCyQpGt1IoCugDmWo4THXyvKDNeyXp5uTo+t003u0HY1azm50dPncPHEMfrVr8Yv06cydsY8ChYpmvi8rcFA2QL6VB16kmLFirF69WrGjRvHzp079Q5HZIGrqysvv/wyCxcu1DsUkQWyI5XV+QT4kOy1cpNzAT4C3jTT9axPSFQsf129k+6OVKPaNmPsjO8oW6mKyde0MYBfRY8MW9F62bBhAwMGDGD37t14eXnpHY7IpF27djFo0CBOnz5tUb0pImOW+Y4g0hGHWvoTQYUKsMUsc6HCUUuN8u/kGndHO0q6Oqb5xxATHU2zDl0ylXCjIiOweXDbYhMuQJs2bZg4cSL+/v48evRI73BEJjVq1AhN02T9tRWy3HcFkYbdqBnIGfv4Y5g4EaKjoUsXqFBBrTvdti2to0OA/WaL0hrVLlnosfW6APYODnQeMiJT13Kys+XNXi8zaNAgHj58aK4QzW748OH4+PjQo0cP4uLiMj5BWAyDwUD//v1lQpUVkqRrVfZh6vjrunXgp1a+0KQJ/PILlCyZ3tEx5Pek62hrQ6MyRbDNZledvY2BlpVLc+TwYRwcHKhRowbr1683U5TmZTAYmDFjBlFRUYwbN07vcEQm9e3bl99//53wcP22GxWZJ0nXquwm+fKg/fuhWjUoXBgGDFB1tQEePIBz56BhQ3BwgDfeUInXNt1NGiKBPTkcu+Ur6uxAk7JFsLMxPHFiVVpsDOBka0Pz8sVwc7DD3d2dOXPmMH/+fF5//XUGDhxoka1ee3t7fv/9d9auXct3332ndzgiE0qXLk2DBg1YsWKF3qGITJCka1UepLj366+wcSNcvKiS7Ecfqcc3boQWLZ6UZNNy32xRWrOizg609iqOh6sjtgYyTL4GVMItV8CZVk8Vx90h5SZvLVq04NixYzg5OVlsq7dw4cKsWbOGd955h7///huAnTt3Eh2dmfXfQg+yZtf6SNK1KvYp7g0fDmXLQpEiMGkS/Pabenzt2qSuZdM5mCXCvMDRzpZGZYrQrFwxyhZwxs7GgI0B7GwMiTcbAzjYGHiqsAsvViiOd8lC2Nmk/efk7u7O7NmzWbBggcW2eitXrszixYvp3r07/fv3p2nTpqxbt07vsEQG2rdvz5EjR7h69areoQgTSdK1Ks+R/L+sbNmkZ8qXh3//BaMRNm+GNm0yc13b+GuL5Ao52VO3VCH8K3nQyqsEz3sWpl6pQjQsXZiXnipBu8olqVmiIG4Opm1h7uvry7Fjx3B2dqZGjRoWl9Tq1atH0aJF+fnnnwH466+/dI5IZMTJyYnu3bvLZidWRJKuVWkAJO3vm7xoTFAQeHqqcd4KFaB4cdOvGhZmYO3aO/JpOR0GgwEXe1tKuDpSys2J4i6OONplrYqBu7s7s2bNYsGCBQwbNowBAwZYTKu3S5cunDt3joSl+5s2bUp5wKNHsGgRDBsG9epB1arw3HPQowfMng1XruR+0IIBAwYwf/582VPbSkjStSovoGYaK7NmwfXrcP++WiLUrVvaXctRUUmTrKKj1dfJt0RxcjKwdu0j6tWrR40aNZgwYQK7du2SZSQ5yNfXl+PHj+Pi4mIxrd6AgAB69OiBk5MTNjY2nDt3jrCwMLh1CwYNUtPfhw5VCfbAAThzBo4fh8WLYexYlYSbN4d9+/T+VvIVb29v3Nzc2LFjh96hCFNowsp00TTNRitfHu3jj9GqVkUrWBCtb1+0sDC0OnXQ9u9H07SkW/nyaJDydvlywvO2mqb11jRN02JjY7U9e/ZokyZN0mrWrKkVLVpU69Wrl/bbb79p9+/f1+sbzvO2bt2qeXl5af369bOIn/Pdu3e1d955R3N0dNROvf++phUooGn29pqmPqtlfHN21rQ339S0yEi9v5V848svv9T69u2rdxjCBLINpNU5BdQlrW0gb92CWrXU2K7py02dgSPA4zsuXbt2jXXr1rFmzRq2b9+Ot7c37dq1o23btjzzzDOy/ZwZhYaGMn78eFauXMm3335L27ZtMz4pp02ZAp99BllZB+rsDHXqwKZN6muRo+7cuUOVKlUICgrC3d1d73DEE0jStUpTgM9IXfTg3Dk4eFANsZnGBXgPeDvDI8PDw/n7779Zs2YNa9aswcHBgXbt2tGuXTt8fHykoLaZ/P333wwaNAgfHx+++uorChcurE8gc+aoLuPsbLzg7Aw+PrB+fWY+BYos6tSpE+3atWPQoEF6hyKeQJKuVYoF2gL/kPXCB85AC2Alavay6TRN4/jx44kJ+OTJk7Ro0YJ27drh5+dHyfS3vhImCA0NZcKECaxYsYK5c+fSrl273A3g4kU1QcocOx25usLXX8PAgdm/lniiP//8k88//1yqR1k4SbpWKwpVlm8rEJbJc12B1sBiUq/9zYo7d+6wfv161q5dy6ZNm6hcuXJiN3Tt2rWxSWf9qniybdu2MXDgQJo2bUpAQEDutXp9fGDXLrX+zBzc3NSMv4IFzXM9kaaYmBjKli3Ljh07qFLF9AIdInfJu6HVcgRWAbMAN1TLNSMugDvwLbAMcyRcgOLFi9O3b1+WLFnC7du3+eyzzwgODqZnz56UKVOGwYMHs2rVKjUTVpisefPmHDt2jAIFClCjRg1Wr16d8y969qyamWzO5SdGI8g60hxnb29P7969mT9/vt6hiCeQlm6ecB/4CQgAbqMScMJyH1tUF7QHMBroDxTKtcjOnz/P2rVrWb16Nfv27aNx48aJY8EVKlTItTis3fbt2xk4cCCNGzdmxowZOdfqHTMGZs6EmBgqALdQv0GugB8wE/URLxrwBK6gPrr9D/UxzgV4C/WbloKXF1y6lDMxi0QnT56kdevWXL16FdvM7QMrcokk3TznLnAI9XZpQCVbb6ConkEBEBwczObNm1mzZg3r1q2jRIkSid3QDRs2xM7OtJ2d8quwsDAmTJjAH3/8wT6ghbUAACAASURBVNy5c/H39zf/i9SsCceOAVAB+B54EbiBGpBoB3wKbEn27wRgJ/AncBO1mnw+kGJTNHt7uHcPZGZtjqtfvz5vvPEG165do2HDhvj4+OgdkkhGkq7QhdFoZP/+/YmTsYKCgmjTpg3t2rWjdevWFClSRJ/AoqPVPpq7d8POnapkk60tPP00NG0KLVuCzuNlCa3eRo0aMWPGDPP9rDRNzTiOUuUjK5CUdAHGAaeBNaiWbJn4f0uj+llaxR/3LnAeNWMgUYECaueWJk3ME6t4jKZprFy5krfeeotLly5hMBj48MMPmTBhgt6hieRyf2mwEI+7du2aNnfuXM3f319zd3fXmjZtqn322WfayZMnNaPRmPMBhIZq2sSJmlawoNoMwsYm7U0fnJ01rUEDTdu6NedjemK4odrIkSM1T09PbdWqVea5aGRkiu+7PGib478OAq0aaO/E338atDOg3Y/fbOVmsp/T76A9m/pnV7Cgpq1YYZ44RZpu3bqlOTo6Jm6A4+rqqi1YsEDvsEQq0tIVFiciIiLFmmA7Ozvatm1Lu3btaNasGU5OTuZ9wR071B6aDx8m7ZeZERcX6NoVvvlGzc7VyY4dOxg4cCANGzbMfqs3Olq1dOMnUVVADVbYAQVRi9SmA/8BLYGLwDWgHGrWQML/ymZgMGq8N1GBArBwIbRvn/X4RIYCAwNp1aoVISEhODk5sXr1al588cWMTxS5RmYvC4vj7OyMn58fs2fP5urVq6xatQpPT0+mTJmCh4cHnTp14ocffuC///7L/ostXqxKMt28aXrCBbWGdckSaNBAdUHrxMfHh6NHj1KkSBFq1KjBn3/+mfWL2durdbXJrAQeAleB2agpemtRk6pATaoCeJTsnEeoOfIpaBqUKZP12IRJnn/+efbs2YO7uzuRkZGULl1a75BEKtLSFVbl7t27bNiwgTVr1rBx40YqVqyYOBva29s7zTXBERERODk5Pb5t5aZN0LEjRGR1gxHAwUFt9L9/v0paOkpo9T7//PN8/fXXWWv1Nm6sxrN5fEw3wUvAKJImSnkCC1CtX1B7nJ0j1ZiuvT2Ehqqfl8hxFy9e5AVfX7buP0KI0YZ7kdFExxrBAE62thRzcaCEiwMero6ynWsuk5ausCrFihWjd+/eLF68mNu3bzNt2jRCQ0Pp06cPpUuXZtCgQaxYsYKQkJDEc6pXr87gwYNTlj578AC6d89ewgXVJXv+PHz4YfauYwYJrd5ixYpRo0YNVq1alfmL+Ps/ca/kCGAf/L+9O4+rss77P/66DvumLIKamuskLmCuIOESaKZZvzG7XRsTS/3d3RZNkCZNZtYvbMEctZlmbM9y0kzH1DEUNPGngCPhFmbpuCsKgrIdznbdf1x4BEFkPRzl83w8fCTXOec631M9eJ/v+mF4uWvTgDeBPOAosBJtY1oFwcESuDZitqiUtPBnxfY0fs4v5T9Xi7lWakJvtqA3WcgvNfJbXhHp5/PZfDybX68UIn0v25Gerrhr/Pbbb2zevJlNmzaRmppKWFgYgwYN4r333kOn0zF69GhWr16Nk5MTPPMMrFplXalbb25uWpm7rl0b5n71lJKSQlRUFCEhISxbtgw/vxpuGbt0CTp2BL2+yp7uJuDDsn9eV8qNfbpuaCd5l9+na3Z3x+HTT2HChDp/HlEzV0oMpJ7Pw2i2YK7hb3YHRcHDyYHQdj54Osu2vcYmPV1x1+jWrRvR0dFs27aN8+fPM3v2bLZu3Yper6e4uJh//vOfDB48mKLz5+GrrxoucAFMJu2MYTsxZMgQDh48SEBAAEFBQWzYsKFmLwwI0BaIubhwkspDy1u4MZ97nQvwCdpcbjaVD8a4XFLCs4mJZGdn1/ZjiFq4WKQn5UwuelPNAxfArKpcM5hIPpVDvt54+xeIepHQFXclLy8vHn/8ceuwmZubGzqdjv3797N95kwoN/fbCa2H5ol2lEgUUFj2mAFoVfbzGiAM7dSl4Te/odEIH38MZvPNjzQZd3d33n//fdasWcNLL73ElClTyM3Nvf0Lly2rtKDquvuBcbVphJsbHps24dayJb169SI+Pp6S+g7pi0ry9EbSzuXVKmxvZrKo7DqTS4nRfv4fvhtJ6Iq72uDBg3nuuef48MMPSU1NpaSkhP/j5lapgs73aMGaAexDm6ME2IUWNJ6AL/AC8PKt3kxRtPqKdiY8PJwDBw7QunVrgoKCWL9+ffUv8PaGdeu0bVE3mQW0rekbe3hAdDReY8aQkJBAWloa+/fvJzAwkK+//rriHLuoM7NFJe18/QK3/L32XciXOd5GJHO6ovnp1AlOnbrxIzU7eem6j4BVwM6b7+vlpdWhnTq1ERrdMHbv3s2MGTMYMGAAy5Yto1WrVrd+8r/+BU88oS02q+2vCXd3mD0bEhIq1dJNSUkhJiYGgCVLlhAup1TVyy+5hRzNLWiQ0AVtjndAW2/aeTXwfngBSE9XNEfV7Ks9gzZv2bfs5y1oh0LUiMEAOTn1alpjCw8PJzMzkzZt2hAcHFx9r3f0aK3iUM+etxxursTVVSvht2oVLFlSZfH6IUOGkJqaSnR0NFOnTuWJJ57g+PHjdfxEzZuqqvyaV9hggQvaHO8vVwpv/0RRJxK6ovmpIgh+j1Z7KRwYBsQBJwAj0L2e97Y37u7uLFmyhLVr1zJv3jwmT55Mzq2+LPToAZmZ8Je/aOHr5qb16Mt/Tnd37ZqvL7z8Mhw/DuOqn/nV6XRMnTqVo0eP0r9/f0JCQoiJiSGvCQ8auRNdLjbUuArjohmTyNy9s8K11576L8YH3oPZZKpw/VqpkSJjxWuiYUjoiuYnIKDSpdudvFQTRgcHClu0aIgW2sQDDzxAZmYm99xzD0FBQXz33XdVP9HREaZNgyNHtG1RK1fCvHna8PELL8D778OOHZCdDa+9BjXdnoS2wG3+/PkcOXKEwsJCAgMDWbZsGUajrKKtiSslBsw1GPrXFxdz/Mgheg0abL226/vvMJurDlYdCnkl8t+gMcicrmh+pk+vUFS9EzU7eem6W83p6nU6+ru6Yu7QgZCQEEJCQggNDSUoKEjbG2zH9uzZQ1RUFH379mXFihXVz/U2osOHDxMbG8uJEyd49913eeyxx+TEpGrsPpPLpWLDbZ+3L/kHtq/9mvl/1f6/Lyq4xrwnxvD8239m/qRHWXP4NA43ldbs5uNBcMCd8yXyTiE9XdH8PPzwbYsUVHXykhnQAybAUvb38n0BV19fDuTns2bNGsLDw9m/fz/Tpk3Dx8eHIUOGEBsby9q1azlz5ozdrQ4NCwsjMzOTdu3aERQUxLp165qkHb1792br1q0sX76cV155hQcffJCMjIwmacudoNRcs7HljB+T6T/sxtfKr9+PZ9TkaXi3qjzqY723SbYONQYJXdH8jBt327nXJGAwNyrnAHyJNuz830BK2d9nXn/Q1RWio3F0ciI4OJiZM2fy8ccfc/jwYc6fP8/ChQvx9fXlyy+/ZMCAAbRr145x48bx9ttvs3PnTgoLm37hipubGwkJCaxbt464uDgmTZrE5cuXm6Qto0aNIjMzkylTpvDII48wffp0zp071yRtsWc1HQXISEmm37AIAH47dICjGfsY8+SMBrm3qB0JXdH8uLjAH/9o3Yd6kpqdvDSdskKl5f58dv1BR0dtjrMKLVq0IDIykri4ODZu3MjFixfZs2cPEydO5OLFi8yfP5/WrVvTp08fZs2axSeffMKRI0eabB/r9V5vhw4dCA4O5ttvv63X/UwWFYPZgslSu969o6Mjs2bN4pdffqFdu3YEBwezYMECu/iCYi88nRwqXdv1/XdM7deNqf268ebMqZz6JQt3Dy9atW2HxWJh5aL5zIh7o9JwcnkK4Olc+d6i/mROVzRPBoO2MvfEiSof/jvwKDU8CMLDA5Yvh6ioejTHwIEDB0hNTSUtLY3U1FQuX77MwIEDrXPDISEhBFSxCKwx7d27l6ioKPr06cOKFSvw9/cnNTWV/Px8Hn745tlujUVVOV+g5+TVYvJLjRjNKoqibfV10il4uzrRsaU793i64qCreW/q9OnTxMXFsWPHDhYtWsT06dNxcGjewXA8r4jDl69Vu2Vo/coVFF67yh9iXqHo2lWeCulJSz9tzt5iNnMt7wrerfyJWfp3eg4IAcBRpxByjw+tPVxs8TGaFQld0XwdOgRhYVrJubpyd4dRo7QTnBp4OC4nJ4f09HRrEKenp+Pt7W0N4NDQUPr27YuLS+P+YiwpKWHBggWsWrWKxYsXExMTg9Fo5PTp07Rs2dL6PFVVOXm1mEOXC0AFUzW/WhwVBRTo3cqLzt7utRrK3LdvHy+++CLXrl0jISGhWRdpLzCYSDp5meoGEf705DgmR8+j18BQVFUlP+fGlEHuxfPM+68x/P3H/bTw8cOprBKUToFHurbGyUEGQxuahK5o3tLSYORI7VjI2p6b7OEBkZHw7bc2qaVrsVg4duyYtSeclpbGL7/8Qu/evSuslu7SpUujzMft3buXUaNGUVRUhJOTE7NmzWJZWZEHg9nC3nNXyNcba3VQg4Oi0NLFkcHtfHFxrPkveFVV+e6775g3bx6BgYG8++679OjRo7Yf6a6QfDKH/NKqt/cUFVxjzkNhfJSSWeVw8qWzZ/jvESEVVi8rQIcWrgxo69OYzW62JHSFOHUKJk+GgwehqOj2z3dy0v7Ex8OcORWKJ9hacXEx+/fvrxDEer3eGsIhISEMGjQIb2/ver/XDz/8wKOPPmrdQ+vs7Mzhw4fp2KUrO07lUGw0U5dfJgrg5ujAgx39cHGs3XBxaWkpH3zwAfHx8UyYMIGFCxfi7+9fh1bcubKLSkk9d6XKLzv//18b2fvDZmKX/q3G93NQ4MGOrWjhYt/b3O5UErpCgDbhuG6dFqRZWdrCqMLCG2cOu7hof8xmeOopeOkl7QxnO3Tu3LkKIZyRkUH79u0rzA0HBQXhWM1Cmqp8+OGHxMfHk52djcViwWg00rNnT1Zs+ZF8vbFOgXudArRwcSSiY6s69dJzc3N54403WLVqFXPnzuX555/H1bX5nB2cdj6PC4X6SsPMmbt34ubhSfe+A2p0HwcFfufrSc9WXo3QSgESukJUdvIkpKdr5w5fvgzOzhAYCP37w8CB2lGIdxCTycThw4crBPHp06fp169fhSBu3779Le+Rm5uL0WikTZs2qKpKXl4eR48eJV/nitH3nhqdinQ7Dgr0aOXFfb7V76GuzrFjx5g3bx6ZmZksXryYCRMmNIutL0azheR6jDYAGEpLMRXkMSXsfnTN4N9ZU5HQFaIZys/PZ9++fRWC2MXFpcLccP/+/fEoK3Qwc+ZMVq9ezcaNG4mI0PZ7miwWNv92qUEC9zoHBcY0wAKenTt3EhMTg7OzM0uWLGHw4MG3f9EdTm8ys+t0LsUmc7ULq6rioIC7TiVm/BieGP84CxYsaJxGCgldIYS2MOnEiROkpaVZg/jQoUN0796dkJAQNmzYQHZ2Nm5ubixatIiYmBhOXi3m4KXqt6uUdyX7IvMmPMLKH/ezZdUn7Fy/hlPHjhL+yO95bvFSQPvl39vfi64+de/tXmexWFi1ahWvvPIKDzzwAPHx8XTu3Lne97VHFouFzz77jNcWvs4/U3/iTGEpFpXb9noVtJXKPVp58TsfDy5dukRkZCTjxo1j0aJFzWKUwNYkdIUQVdLr9WRmZrJ7927mzp1rPbpSURT69u3Lu+u2kl9a8cD8b5a/B8DE52Ir3W/72q84diCDZ99MIDVxC4pOIXP3jxj0emvoArRwdmRE54ZbDFVcXExCQgJLly7lmWeeIS4ursJWpzuZxWJh7dq1zJ07l7Nnz6IoCkajkWsGE79eKeRsgR6domBRVWvv10FRrPumO3m70c3HAw+nG/P7ly9fZsSIEYwePZr4+HgJ3gZWu5UUQohmw9XVldBQbW+nTqfDw8ODkpIS2rZtS6fOnblmqF3pt4xdyQx9dDwAoQ9p530dP3yQ3IsXKjyv0GBCVdUG+2Xv7u7Oq6++yjPPPMOrr75K9+7defXVV5k1a5bdF6K4ncjISPbu3UtpaSkAQUFBKIpCSxcnBrT1oW9rlaulRvL0Rgxl5zS7Ojrg4+pECxfHKudu/f39SU5OZuTIkRgMBhISEiR4G5DsfBZCVKtNmzbExsbyzTffcOXKFU6dOsWXq7+hNr+GTUYjP+9LpU/Y0Ns+V1EUiowNf9h+27Zt+eijj/jhhx/YsGEDwcHBbNq0ye6KT9RGXFxchS8OISEhFR530Cn4ujnT1ceDHq286FF2GIm3q1O1i6X8/PxISkoiJSWF6OjoO/rfkb2R0BVCVKtz584sXryYhx9+GM+y6kwmi6VWvZ+f/51Kp8BeuN2muhNoB3vV9pzm2ujTpw+JiYkkJCTw0ksvMXLkSA4cONBo79eYQkND8ff3p0uXLuh0OgYNGtRg9/bx8WHbtm2kp6fz7LPPNtlZ4HcbCV0hRK3pFMW6hfmt2dP4w8BA/jAwkPUrP2D9yg+sP781exqglZbrNzSiZjdXtcU9jUlRFMaMGcPBgwd5/PHHGTVqFE8//TTnz59v3DduQKqqMnv2bEaMGMGxY8f485//zNixYxv0Pby9vUlMTOTQoUPMnj1bgrcByEIqIUStWVSVfx67WGl17K0WUj0/ZihzV3xM+y6/q3D966Vvk3vxQoWFVArw2O/a1KoYQn1dvXqV+Ph4Vq5cSXR0NDExMdbtUvZq5cqVLF++nLS0NNwaee94YWEhY8eOpVOnTnz88cfNvtBEfUhPVwhRazpFwaOKsnJVyT57GqPBUCFwzSYThlI9FrMZi8WMoVSP2WQqe/4ZIh4czqJFi9izZ4/12MnG1LJlSxYvXsz+/fvJysqie/fufP7553bbszt48CBxcXGsWbOm0QMXwNPTk82bN3PmzBmmTZuGyVS7RXTiBgldIUSddGjhVqNh4P07t1caWv72r0uZ3KcL61euYNfGdUzu04Vv/7oUHRDSoytxcXEUFBQwZ84cWrVqxdixY1m6dCmHDh1q1EU9nTp1YvXq1Xz77bf87W9/Y8CAAezYsaPR3q8uCgsLmTBhAkuWLCEwMNBm7+vh4cGmTZvIyclh6tSpNvkydDeS4WUhRJ3oTWa2nrh029OP3pz1JKOnRtF/WORt76lT4KHOAbiX60Xn5OSwY8cOtm/fTlJSEoWFhURERDBixAgiIyPp2LFjfT9KlVRVZe3atbz88ssEBQXxzjvv0L1790Z5r9q06amnnsLR0ZFPPvmkSdqg1+sZP348rq6urF69GueycoCiZiR0hRB1lpl9lVNXi6s9lWrDRx8w+skZuLhWPwyqU7Tec/821VdEOnnyJElJSdYQbtmyJZGRkURGRhIREYGfn19dPsot6fV6li9fzjvvvMPkyZN57bXXGvw9aurTTz/lvffeIz09vUnnnEtLS5k4cSKqqrJmzZpGr+l8N5HQFULUmcmikvifS+hN9Z/7dHHQMaqLP461KJVosVg4fPiwNYRTUlLo1q2btRc8ZMgQ3N3d69020E5qev311/nmm294+eWXmTNnjk3D5siRIwwfPpydO3fSq1cvm73vrRgMBiZPnoxer2fdunXNqqpTfUjoCiHq5VqpkZ2nc+u1t9ZRURh2rx8tXet3QpTBYCA9Pd0awj/99BMDBgywhvDAgQNrXdLwZllZWcydO5eff/6Zt99+m/Hjx9f6xCZVVbmiN3K+QE9OiUGrDqSqOOi006QC3F1o18IVt7L6wkVFRQwaNIjY2FiioqLq1f6GZDQaefLJJ8nPz2fDhg02WdR1p5PQFULU29VSI7vPXMFosdSqwo1OAUedQnh7P7zrGbhVKSgoICUlxRrCp06dYujQodYQ7tmzZ52POExKSiImJgZPT0+WLFliPZji3Llz5OXl0bt37ypfd66ghEOXCyg1WW5Zoen6AjV/dxfuD2jBc/93FiaTic8//9zujmQ0mUxMnz6dCxcusHHjRrvfatXUJHSFEA3CaLFwIPsaZwtKUG9T4UZBO3mqnacr97duWe9SfjV16dIlkpOTrSGs1+uJjIy0hnCHDh1qdT+z2cwXX3zBn/70J4YPH85bb73FpEmTyMrK4vjx4xXmfg1mC/++kM/lYkONyyEqgMVs5vuVy1m+6E94edlncXmz2czTTz/Nf/7zHzZv3mw9uUxUJqErhGhQhQYTx/OKOFNQgsmsoiu3r8hiUXHUKbT3cqOrrwdezk1bc+XEiRPWBVlJSUn4+flZQ3j48OH4+vrW6D6FhYW8++67LFmyhNLSUhRFYfTo0WzYsAGAUpOFnadzKDGaqcvst6KqdPX1IMi/hd31dK+zWCzMnj2brKwstmzZQosWLZq6SXZJQlcI0WhKTRYKDEbMqlYr18vZERdH+zzNyGKxcPDgQWsI7969m8DAQOvK6PDw8GrnLE0mEx07drQeJens7Mxnn33GxEmTSD6ZQ4HBdNv6ttVxUBR6tvLkd77224u0WCzMmTOHn376ia1bt941JRQbkoSuEEJUwWAwkJqaag3hAwcOMGjQIOtQdP/+/SssyoqPjycuLg53d3cURaG4uBhFUcg8l8OJa/pqt1XVlIMCEZ38m3yEoDqqqhIdHc3evXtJTEzEx8enqZtkVyR0hRCiBq5du8auXbusIXz27FmGDRtmDeGYmBgSExMJDQ3lvffew2QycfpCNu59wmq1uOx2/FydGNaxVcPdsBGoqkpsbCw7duxg27ZtTbav2R5J6AohRB1cvHjRuihr27ZtnD17FlVVcXJyokuXLqSkpJCNC79dKarTPO6t6BSItPPeLmjBO3/+fLZs2UJSUhL+/v5N3SS7IKErhBD19NNPPxEWFoZer7de8/b25sv0LAw3dXOTv/uGgHYd6B0SZr12NGMfX7yziLf+8T0Lpj3BmV+PYjQYCGh/L5Oej2VQ5MPW5ypANx8PggLsf6GSqqosWLCA9evXk5SUROvWrZu6SU3Ovr8qCSHEHeDIkSOYTCYCAwMZOnQoYWFh9L6/H2fK9WkS//ElLf20YWFVVUn8ZhUtff0IGTmajF3J9Cs7m3rGK4vo0PU+HBwdOXYgg9ejJrJi6258ArTAUoHLxQabf8a6UBSFN954AycnJ4YPH05ycjJt27Zt6mY1KQldIYSop6lTpzJp0qQKC6suFuo5dyEfS1nwRoyfxOYvPmLX9+twdnEj8olJDIwcBUDGriSefUOrRdype0/rPRRFwWwykXPxvDV0AQoMd1ZpvQULFuDk5MSwYcNITk6mffv2Td2kJiOhK4QQ9aQoSqXjJY2WyieEXN9jqyig0zmgKAp5l7K5mpND555B1ue9NXsaB/emYDSUcn/4cLr27lPhPjU9XMOezJ8/v0KP9957723qJjUJCV0hhGgENx9hkbzuHwS0v5dHps3E/572XDh5gvSkrRTk53H/kOEVDr2I+9sXmIxGDu5N4dyJ39DVogiEPYuNjcXR0dEavJ06dWrqJtnc3fFfUggh7Iy7k0OF5H1o0h8IfWgMoPV4H5r0B0JGjCbjx2T6Da1ca9jRyYl+QyPI3L2Tfck/VHjMxUbHZjaGF154gZiYGIYNG8bx48ebujk2Jz1dIYRoBC1dnDBXsUE34vGJ1r+bjEZ+3reXOfHv3/I+ZrOJi6dPVbjm0wjFIWzpf/7nf3BycuLBBx9k+/bt3HfffU3dJJu5c78uCSGEHdPK9FXfr8nan0bH7j1x99QKGZw98SsZu5Ip1ZdgMhr5ceM6sv6dRq+BoTfuq8A9nnd+7dpZs2axcOFCIiIiyMrKaurm2Iz0dIUQopHc5+vJ/otXb7nwKePHJPoNjbhxQYU1KxI489sxdA4OtO3YmReXfEiXXsHlXqXQvsXdUbd2xowZODk5ERkZSWJi4i3LId5N5HAMIYRoJBZV5YcTlygxVX0mVfQjw4j980o6dKvZ8KqDAl19POjtb/8HY9TG6tWrefHFF9m6dSvBwcF89dVXjB07Fm9v76ZuWoNzWLhw4cKmboQQQtyNFEXBz82Z09dKKlUYMhoMlOpLCB05psb3c3NyILSdj92W96uroKAgOnbsyJQpU8jKymLBggW0bt2awYMHN3XTGpz0dIUQopH9klvI0dyCelUactQpDL/XjxYud/YiqupMnDiRNWvWANCzZ0+OHDlS8Ql6PWzYAElJsGcP5ORom55bt4YHHoCRI2HsWHCy339HErpCCGEDR3MK+OVKYa2DV0EL3CEd/PC+w1ctV+fzzz8nKiqK65Hk7OzM0aNH6dy5M5SUwOuvwwcfaCFbUFD1Tby8wMEBXnwR5s0DZ2cbfoKakeFlIYSwgVbuLvi5OZNdVAqoNSpo76Ao+Hu4EN7BF087rypUX97e3qiqysmTJzGbzZSWlqLX6xkbEADh4bBzJxQXg6Gac6cNBq03nJYGX34JEREQEGCzz1AT0tMVQggbMlksnL5awrG8IvQmMzpFwWzRQlinYP05wN2Z+/w88Xd3aeom25Sqqhw8eJB33nmH/rm5vJiSooVtbSkKeHhAYiLY0dywhK4QQjQBVVXRmyzk6Y0UGU1YVG0YuaWLE96ujjjeJUc/1tmBAxAWVrfALc/LCzIzoUuXhmlXPUnoCiGEsC8GA/TqBcePQ30jysEB+vbVhpzt4ItM07dACCGEKO+DD+D8+foHLoDZDFlZ8PXX9b9XA5CerhBCCPthsUD79nDhQsPet2dPuHkLUhOQnq4QQgj7sWcPFBZaf+wEuAGeQGsgCrj+qAFoVe7n7UA/wAPoAKwpf9+TJ7UebxOT0BVCCGE/9u6F0tIKl75HC9YMYB/wZtn1XcD9aIH8MzAF+H/AVSAT6F/+JjodpKY2ZstrREJXCCGE/di9+5Z7cdsBo4HDZT9vAa4fovkmMLvscUfAD+ha/sWFhdpiqiYmoSuEEMJ+jXOTCgAAAvRJREFU5OTc8qEzaEHbt+znLcAjZX+/3ocNAtoCTwJXbr7BpUsN1co6k9AVQghhPxwcKl36PeANhAPDgDjgBGAEupc95yzwJbAO+BUoAZ67+UaOTX+ql4SuEEII+9G9e6VLG4B84BTwF7SFVZu5MbRM2bUo4D60Od44tJ6wlYMDBAY2SpNrQ0JXCCGE/QgL045vvI3yQ8sAwWjFIW7JwwMGDqxf2xqAhK4QQgj7ERGhHWhRjRIgHRhe7loU8CnasHMx8DYwtvyLDAat/F8Tk9AVQghhPzp2hJCQap+SBAwGXMtdmwFMA0KAjoALsOz6gzodPPYY+Po2eHNrS06kEkIIYV9274ZRo25Z7OBZoHfZP2vEzQ3S06F37wZqYN1JT1cIIYR9CQ+HqVPB1bXKh+8HxtX0Xu7uWlF7OwhckJ6uEEIIe1RUBKGhcOxY9YXrq+PqCv36wY4d4OzcsO2rI+npCiGEsD8eHrBrF/ToofVW6/L6gQO1IvZ2ErggoSuEEMJe+fjAvn3wxz9q87I1OdzC2VkL6YULtR5uDbYf2ZIMLwshhLB/x47B++/DF19oB12YzaDXg6Jow8iKov155hmIjtZWQdshCV0hhBB3DoNBq4ubkQHZ2dp2oDZtoH9/bSjaDo56rI6ErhBCCGEjMqcrhBBC2IiErhBCCGEjErpCCCGEjUjoCiGEEDYioSuEEELYiISuEEIIYSMSukIIIYSNSOgKIYQQNiKhK4QQQtiIhK4QQghhIxK6QgghhI1I6AohhBA2IqErhBBC2IiErhBCCGEjErpCCCGEjUjoCiGEEDYioSuEEELYiISuEEIIYSMSukIIIYSNSOgKIYQQNiKhK4QQQtiIhK4QQghhIxK6QgghhI1I6AohhBA2IqErhBBC2IiErhBCCGEjErpCCCGEjUjoCiGEEDYioSuEEELYiISuEEIIYSMSukIIIYSNSOgKIYQQNiKhK4QQQtiIhK4QQghhIxK6QgghhI1I6AohhBA28r/5AQiVYRaSgQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "G1.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Graphical Representation of the Reverse Graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "G2.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Forward Propogation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_traversal = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfs = DirectedDFS(G2,node_list)\n",
    "dfs.dfs(reverse_start_node)\n",
    "none = [my_traversal.append(my_node) for my_node in dfs.return_traversal()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*/0\n",
      "[4.0, 2.0] mapped values\n",
      "8.0 result\n",
      "+/1\n",
      "[8.0, 3.0] mapped values\n",
      "11.0 result\n",
      "*/3\n",
      "[5.0, 11.0] mapped values\n",
      "55.0 result\n",
      "+/2\n",
      "[2.0, 5.0] mapped values\n",
      "7.0 result\n",
      "-/4\n",
      "[7.0, 55.0] mapped values\n",
      "48.0 result\n",
      "[48.0]\n"
     ]
    }
   ],
   "source": [
    "forward_propogation(my_traversal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Backward Propogation\n",
    "###### The output of the backward propogation is like:\n",
    "\n",
    "(operation) my node \n",
    "\n",
    "(value1) inputs  \n",
    "\n",
    "(value2) inputs\n",
    "\n",
    "###### And the result should follow like:\n",
    "\n",
    "(value2)'s derivative\n",
    "\n",
    "(value1)'s derivative\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "none = [my_traversal.append(my_node) for my_node in dfs.return_traversal()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*/0 my node\n",
      "4.0 inputs\n",
      "2.0 inputs\n",
      "4 The Derivative\n",
      "2 The Derivative\n",
      "+/1 my node\n",
      "8.0 inputs\n",
      "3.0 inputs\n",
      "1 The Derivative\n",
      "1 The Derivative\n",
      "*/3 my node\n",
      "5.0 inputs\n",
      "11.0 inputs\n",
      "5 The Derivative\n",
      "11 The Derivative\n",
      "+/2 my node\n",
      "2.0 inputs\n",
      "5.0 inputs\n",
      "1 The Derivative\n",
      "1 The Derivative\n",
      "-/4 my node\n",
      "7.0 inputs\n",
      "55.0 inputs\n",
      "1 The Derivative\n",
      "-1 The Derivative\n"
     ]
    }
   ],
   "source": [
    "backward_propogation(my_traversal)"
   ]
  }
 ],
 "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
}