{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# The Application of Quantum Neural Network in NLP\n", "\n", "[![Download Notebook](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/resource/_static/logo_notebook_en.svg)](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/master/mindquantum/en/case_library/mindspore_qnn_for_nlp.ipynb) \n", "[![Download Code](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/resource/_static/logo_download_code_en.svg)](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/master/mindquantum/en/case_library/mindspore_qnn_for_nlp.py) \n", "[![View source on Gitee](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/resource/_static/logo_source_en.svg)](https://gitee.com/mindspore/docs/blob/master/docs/mindquantum/docs/source_en/case_library/qnn_for_nlp.ipynb)\n", "\n", "## Overview\n", "\n", "Word embedding plays a key role in natural language processing. It embeds a high-dimension word vector to lower dimension space. When more information is added to the neural network, the training task will become more difficult. By taking advantage of the characteristics of quantum mechanics (e.g., state superposition and entanglement), a quantum neural network can process such classical information during training, thereby improving the accuracy of convergence. In the following, we will build a simple mixed quantum neural network for completing word embedding task.\n", "\n", "Import relevant dependencies of the tutorial." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import time\n", "import mindspore as ms\n", "import mindspore.ops as ops\n", "import mindspore.dataset as ds\n", "from mindspore import nn\n", "from mindquantum.framework import MQLayer\n", "from mindquantum.core.gates import RX, RY, X, H\n", "from mindquantum.core.circuit import Circuit, UN\n", "from mindquantum.core.operators import Hamiltonian, QubitOperator" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This tutorial implements a [CBOW model](https://blog.csdn.net/u010665216/article/details/78724856), which predicts a word based on its position. For example, \"I love natural language processing\", this sentence can be divided by five words, which are \\[\"I\", \"love\", \"natural\", \"language\", \"processing\"\\]. When the selected window is 2, the task to be completed would be to predict the word \"natural\" given \\[“I”, “love”, “language”, “processing”\\]. In the following, we will build a quantum neural network for word embedding to deal with the this task.\n", "\n", "![quantum word embedding](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/docs/mindquantum/docs/source_en/images/qcbow.png)\n", "\n", "Here, the encoding information of \"I\", \"love\", \"language\", and \"processing\" will be encoded to the quantum circuit. This quantum circuit to be trained consists of four Ansatz circuits. At last, we measure the qubit in the $\\text{Z}$ base vector for the quantum circuit end. The number of measured qubits is determined by the embedded dimenson.\n", "\n", "## Data Pre-processing\n", "\n", "It is necessary to form a dictionary for the setence to be processed and determine the samples according to the size of the window." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'I': 0, 'language': 1, 'love': 2, 'natural': 3, 'processing': 4}\n", "word dict size: 5\n", "samples: [[['I', 'love', 'language', 'processing'], 'natural']]\n", "number of samples: 1\n" ] } ], "source": [ "def GenerateWordDictAndSample(corpus, window=2):\n", " all_words = corpus.split()\n", " word_set = list(set(all_words))\n", " word_set.sort()\n", " word_dict = {w: i for i, w in enumerate(word_set)}\n", " sampling = []\n", " for index, _ in enumerate(all_words[window:-window]):\n", " around = []\n", " for i in range(index, index + 2*window + 1):\n", " if i != index + window:\n", " around.append(all_words[i])\n", " sampling.append([around, all_words[index + window]])\n", " return word_dict, sampling\n", "\n", "word_dict, sample = GenerateWordDictAndSample(\"I love natural language processing\")\n", "print(word_dict)\n", "print('word dict size: ', len(word_dict))\n", "print('samples: ', sample)\n", "print('number of samples: ', len(sample))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "According to the above information, the size of the dictionary is 5 and it is enough to select a sample.\n", "\n", "## Encoding Circuit\n", "\n", "For simplification, we use the $\\text{RX}$ rotation gate to construct the encoding circuit. The structure is as follows.\n", "\n", "![encoder circuit](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/docs/mindquantum/docs/source_en/images/encoder.png)\n", "\n", "We apply a $\\text{RX}$ rotation gate to each quantum qubit." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "q0: q1: q2: RX e_0 RX e_1 RX e_2 " ], "text/plain": [ "" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def GenerateEncoderCircuit(n_qubits, prefix=''):\n", " if prefix and prefix[-1] != '_':\n", " prefix += '_'\n", " circ = Circuit()\n", " for i in range(n_qubits):\n", " circ += RX(prefix + str(i)).on(i)\n", " return circ.as_encoder()\n", "\n", "GenerateEncoderCircuit(3, prefix='e').svg()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "$\\left|0\\right>$ and $\\left|1\\right>$ are used to mark the two states of a two-level qubit. According to the state superposition theory, qubit can also be in the superposition of these two states:\n", "\n", "$$\\left|\\psi\\right>=\\alpha\\left|0\\right>+\\beta\\left|1\\right>$$\n", "\n", "For the quantum state of a $n$ bits, it can be in a $2^n$ Hilbert space. For the dictionary composed by the above 5 words, we only need $\\lceil \\log_2 5 \\rceil=3$ qubits to complete the encoding task, which demonstrates the superiority of quantum computing.\n", "\n", "For example. given the word \"love\" in the above dictionary, its corresponding label is 2, represented by `010` in the binary format. We only need to set `e_0`, `e_1`, and `e_2` to $0$, $\\pi$, and $0$ respectively." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Label is: 2\n", "Binary label is: 010\n", "Parameters of encoder is: \n", " [0. 3.14159 0. ]\n", "Encoder circuit is: \n", "\n", " ┏━━━━━━━━━┓ \n", "q0: ──┨ RX(e_0) ┠───\n", " ┗━━━━━━━━━┛ \n", " ┏━━━━━━━━━┓ \n", "q1: ──┨ RX(e_1) ┠───\n", " ┗━━━━━━━━━┛ \n", " ┏━━━━━━━━━┓ \n", "q2: ──┨ RX(e_2) ┠───\n", " ┗━━━━━━━━━┛ \n", "Encoder parameter names are: \n", " ['e_0', 'e_1', 'e_2']\n", "Amplitude of quantum state is: \n", " [0. 0. 1. 0. 0. 0. 0. 0.]\n", "Label in quantum state is: 2\n" ] } ], "source": [ "from mindquantum.simulator import Simulator\n", "\n", "n_qubits = 3 # number of qubits of this quantum circuit\n", "label = 2 # label need to encode\n", "label_bin = bin(label)[-1:1:-1].ljust(n_qubits, '0') # binary form of label\n", "label_array = np.array([int(i) * np.pi for i in label_bin]).astype(np.float32) # parameter value of encoder\n", "encoder = GenerateEncoderCircuit(n_qubits, prefix='e') # encoder circuit\n", "encoder_params_names = encoder.params_name # parameter names of encoder\n", "\n", "print(\"Label is: \", label)\n", "print(\"Binary label is: \", label_bin)\n", "print(\"Parameters of encoder is: \\n\", np.round(label_array, 5))\n", "print(\"Encoder circuit is: \\n\")\n", "print(encoder)\n", "print(\"Encoder parameter names are: \\n\", encoder_params_names)\n", "\n", "state = encoder.get_qs(pr=dict(zip(encoder_params_names, label_array)))\n", "amp = np.round(np.abs(state) ** 2, 3)\n", "\n", "print(\"Amplitude of quantum state is: \\n\", amp)\n", "print(\"Label in quantum state is: \", np.argmax(amp))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Through the above verification, for the data with label 2, the position where the largest amplitude of the quantum state is finally obtained is also 2. Therefore, the obtained quantum state is exactly the encoding information of input label. We summarize the process of generating parameter values through data encoding information into the following function." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(array([[0. , 0. , 0. , 0. , 3.1415927, 0. ,\n", " 3.1415927, 0. , 0. , 0. , 0. , 3.1415927]],\n", " dtype=float32),\n", " array([3], dtype=int32))" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def GenerateTrainData(sample, word_dict):\n", " n_qubits = int(np.ceil(np.log2(1 + max(word_dict.values()))))\n", " data_x = []\n", " data_y = []\n", " for around, center in sample:\n", " data_x.append([])\n", " for word in around:\n", " label = word_dict[word]\n", " label_bin = bin(label)[-1: 1: -1].ljust(n_qubits, '0')\n", " label_array = [int(i)*np.pi for i in label_bin]\n", " data_x[-1].extend(label_array)\n", " data_y.append(word_dict[center])\n", " return np.array(data_x).astype(np.float32), np.array(data_y).astype(np.int32)\n", "\n", "GenerateTrainData(sample, word_dict)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "According to the above result, we merge the encoding information of these 4 input words into a longer vector for further usage of the neural network.\n", "\n", "## Ansatz Circuit\n", "\n", "There is a variety of selections for the Ansatz circuits. We select the below quantum circuit as the Ansatz circuit. A single unit of the Ansatz circuit consists of a [RY](https://www.mindspore.cn/mindquantum/docs/en/master/core/gates/mindquantum.core.gates.RY.html) gate and a [CNOT](https://www.mindspore.cn/mindquantum/docs/en/master/core/gates/mindquantum.core.gates.CNOTGate.html) gate. The full Ansatz circuit can be obtained by repeating $p$ times over this single unit.\n", "\n", "![ansatz circuit](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/docs/mindquantum/docs/source_en/images/ansatz.png)\n", "\n", "The following function is defined to construct the Ansatz circuit." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "q0: q1: q2: q3: q4: RY a_0_0 RY a_0_1 RY a_0_2 RY a_0_3 RY a_0_4 RY a_1_0 RY a_1_1 RY a_1_2 RY a_1_3 RY a_1_4 " ], "text/plain": [ "" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def GenerateAnsatzCircuit(n_qubits, layers, prefix=''):\n", " if prefix and prefix[-1] != '_':\n", " prefix += '_'\n", " circ = Circuit()\n", " for l in range(layers):\n", " for i in range(n_qubits):\n", " circ += RY(prefix + str(l) + '_' + str(i)).on(i)\n", " for i in range(l % 2, n_qubits, 2):\n", " if i < n_qubits and i + 1 < n_qubits:\n", " circ += X.on(i + 1, i)\n", " return circ.as_ansatz()\n", "\n", "GenerateAnsatzCircuit(5, 2, 'a').svg()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Measurement\n", "\n", "We treat the measurements of different qubits as the data after dimension reduction. This process is similar to qubit encoding. For example, when we want to reduce the dimension of the word vector to 5, we can process the data in the 3rd dimension as follows:\n", "\n", "- 3 in the binary format is 00011.\n", "- Measure the expectation value of the Z0Z1 hams at the quantum circuit end.\n", "\n", "The below function gives the hams to generate the data in all dimension, where n_qubits represents the number of qubits, dims represents the dimension of word embedding." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1 [Z0], 1 [Z1], 1 [Z0 Z1], 1 [Z2], 1 [Z0 Z2]]" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def GenerateEmbeddingHamiltonian(dims, n_qubits):\n", " hams = []\n", " for i in range(dims):\n", " s = ''\n", " for j, k in enumerate(bin(i + 1)[-1:1:-1]):\n", " if k == '1':\n", " s = s + 'Z' + str(j) + ' '\n", " hams.append(Hamiltonian(QubitOperator(s)))\n", " return hams\n", "\n", "GenerateEmbeddingHamiltonian(5, 5)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Quantum Word Embedding Layer\n", "\n", "The quantum word embedding layer combines the above-mentioned encoding quantum circuit, the quantum circuit to be trained, and the measurement of hams. `num_embedding` words can be embedded into a word vector with `embedding_dim` dimension. Here, a Hadamard gate is added at the beginning of the quantum circuit. The initialization state is set to average superposition state for improving the representation ability of the quantum neural network.\n", "\n", "In the following, we define a quantum embedding layer and it returns a quantum circuit simulation operator." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "def QEmbedding(num_embedding, embedding_dim, window, layers, n_threads):\n", " n_qubits = int(np.ceil(np.log2(num_embedding)))\n", " hams = GenerateEmbeddingHamiltonian(embedding_dim, n_qubits)\n", " circ = Circuit()\n", " circ = UN(H, n_qubits)\n", " encoder_param_name = []\n", " ansatz_param_name = []\n", " for w in range(2 * window):\n", " encoder = GenerateEncoderCircuit(n_qubits, 'Encoder_' + str(w))\n", " ansatz = GenerateAnsatzCircuit(n_qubits, layers, 'Ansatz_' + str(w))\n", " encoder.no_grad()\n", " circ += encoder\n", " circ += ansatz\n", " encoder_param_name.extend(encoder.params_name)\n", " ansatz_param_name.extend(ansatz.params_name)\n", " grad_ops = Simulator('mqvector', circ.n_qubits).get_expectation_with_grad(hams,\n", " circ,\n", " parallel_worker=n_threads)\n", " return MQLayer(grad_ops)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The training model is similar to a classical network, composed by an embedded layer and two fully-connected layers. However, the embedded layer here is constructed by a quantum neural network. The following defines the quantum neural network CBOW." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "class CBOW(nn.Cell):\n", " def __init__(self, num_embedding, embedding_dim, window, layers, n_threads,\n", " hidden_dim):\n", " super(CBOW, self).__init__()\n", " self.embedding = QEmbedding(num_embedding, embedding_dim, window,\n", " layers, n_threads)\n", " self.dense1 = nn.Dense(embedding_dim, hidden_dim)\n", " self.dense2 = nn.Dense(hidden_dim, num_embedding)\n", " self.relu = ops.ReLU()\n", "\n", " def construct(self, x):\n", " embed = self.embedding(x)\n", " out = self.dense1(embed)\n", " out = self.relu(out)\n", " out = self.dense2(out)\n", " return out" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the following, we use a longer sentence for training. Firstly, we define `LossMonitorWithCollection` to supervise the convergence process and record the loss." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "class LossMonitorWithCollection(ms.train.callback.LossMonitor):\n", " def __init__(self, per_print_times=1):\n", " super(LossMonitorWithCollection, self).__init__(per_print_times)\n", " self.loss = []\n", "\n", " def on_train_begin(self, run_context):\n", " self.begin_time = time.time()\n", "\n", " def on_train_end(self, run_context):\n", " self.end_time = time.time()\n", " print('Total time used: {}'.format(self.end_time - self.begin_time))\n", "\n", " def on_train_epoch_begin(self, run_context):\n", " self.epoch_begin_time = time.time()\n", "\n", " def on_train_epoch_end(self, run_context):\n", " cb_params = run_context.original_args()\n", " self.epoch_end_time = time.time()\n", " if self._per_print_times != 0 and cb_params.cur_step_num % self._per_print_times == 0:\n", " print('')\n", "\n", " def on_train_step_end(self, run_context):\n", " cb_params = run_context.original_args()\n", " loss = cb_params.net_outputs\n", "\n", " if isinstance(loss, (tuple, list)):\n", " if isinstance(loss[0], ms.Tensor) and isinstance(loss[0].asnumpy(), np.ndarray):\n", " loss = loss[0]\n", "\n", " if isinstance(loss, ms.Tensor) and isinstance(loss.asnumpy(), np.ndarray):\n", " loss = np.mean(loss.asnumpy())\n", "\n", " cur_step_in_epoch = (cb_params.cur_step_num - 1) % cb_params.batch_num + 1\n", "\n", " if isinstance(loss, float) and (np.isnan(loss) or np.isinf(loss)):\n", " raise ValueError(\"epoch: {} step: {}. Invalid loss, terminating training.\".format(\n", " cb_params.cur_epoch_num, cur_step_in_epoch))\n", " self.loss.append(loss)\n", " if self._per_print_times != 0 and cb_params.cur_step_num % self._per_print_times == 0:\n", " print(\"\\repoch: %+3s step: %+3s time: %5.5s, loss is %5.5s\" % (cb_params.cur_epoch_num, cur_step_in_epoch, time.time() - self.epoch_begin_time, loss), flush=True, end='')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next, embed a long setence by using the quantum `CBOW`. This command sets the thread of the quantum simulators to 4. When the number of qubits to be simulated is large, more threads can be set to improve the simulation efficiency." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "epoch: 25 step: 20 time: 0.247, loss is 0.103\n", "epoch: 50 step: 20 time: 0.265, loss is 0.049\n", "epoch: 75 step: 20 time: 0.259, loss is 0.031\n", "epoch: 100 step: 20 time: 0.245, loss is 0.022\n", "epoch: 125 step: 20 time: 0.249, loss is 0.019\n", "epoch: 150 step: 20 time: 0.270, loss is 0.020\n", "epoch: 175 step: 20 time: 0.305, loss is 0.020\n", "epoch: 200 step: 20 time: 0.234, loss is 0.023\n", "epoch: 225 step: 20 time: 0.236, loss is 0.026\n", "epoch: 250 step: 20 time: 0.231, loss is 0.021\n", "epoch: 275 step: 20 time: 0.240, loss is 0.024\n", "epoch: 300 step: 20 time: 0.281, loss is 0.022\n", "epoch: 325 step: 20 time: 0.235, loss is 0.018\n", "epoch: 350 step: 20 time: 0.255, loss is 0.018\n", "Total time used: 91.56754469871521\n" ] } ], "source": [ "import mindspore as ms\n", "ms.set_context(mode=ms.PYNATIVE_MODE, device_target=\"CPU\")\n", "corpus = \"\"\"We are about to study the idea of a computational process.\n", "Computational processes are abstract beings that inhabit computers.\n", "As they evolve, processes manipulate other abstract things called data.\n", "The evolution of a process is directed by a pattern of rules\n", "called a program. People create programs to direct processes. In effect,\n", "we conjure the spirits of the computer with our spells.\"\"\"\n", "\n", "ms.set_seed(42)\n", "window_size = 2\n", "embedding_dim = 10\n", "hidden_dim = 128\n", "word_dict, sample = GenerateWordDictAndSample(corpus, window=window_size)\n", "train_x, train_y = GenerateTrainData(sample, word_dict)\n", "\n", "train_loader = ds.NumpySlicesDataset({\n", " \"around\": train_x,\n", " \"center\": train_y\n", "}, shuffle=False).batch(3)\n", "net = CBOW(len(word_dict), embedding_dim, window_size, 3, 4, hidden_dim)\n", "net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')\n", "net_opt = nn.Momentum(net.trainable_params(), 0.01, 0.9)\n", "loss_monitor = LossMonitorWithCollection(500)\n", "model = ms.Model(net, net_loss, net_opt)\n", "model.train(350, train_loader, callbacks=[loss_monitor], dataset_sink_mode=False)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Print the loss value during convergence:" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAGwCAYAAABVdURTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABtM0lEQVR4nO3de1yUdfo//teNCoLKiCIw4HAQTTwgeAJR0zyUmW2S7a4r7Vc7n9Dss/trFXfb7bCFrZ/201ZmarvSbqGWx9Y8ZJ4NEkRBPJYKQjqghAwKExjcvz9wpplhZpjDPefX8/HgUczc98z7Hkbm4v2+3tcliKIogoiIiMhL+Ll6AERERERSYnBDREREXoXBDREREXkVBjdERETkVRjcEBERkVdhcENERERehcENEREReZXOrh6As7W2tuLKlSvo0aMHBEFw9XCIiIjIAqIo4saNG4iMjISfn/m5GZ8Lbq5cuQKFQuHqYRAREZENKisr0bdvX7PH+Fxw06NHDwBtL05wcLCLR0NERESWqK+vh0Kh0H6Om+NzwY1mKSo4OJjBDRERkYexJKWECcVERETkVRjcEBERkVdhcENERERehcENEREReRUGN0RERORVGNwQERGRV2FwQ0RERF6FwQ0RERF5FQY3RERE5FUY3BAREZFXYXBDREREXoXBjZMoVWrkXaiBUqV29VCIiIi8ms81znQmpUqNo+W12HZCiS9PVUMEIABYPD0BT0+Md/XwiIiIvBKDGwdZefACsrefbXe7CCB7x1lAAJ6ewACHiIhIam6zLLV06VIIgoAXXnjB7HGfffYZEhIS0LVrVyQmJmL79u3OGaAFlCo1/ltyGS+sO240sNH15o6zXKIiIiJyALeYuSksLMTKlSsxbNgws8fl5eVhzpw5yM7Oxv3334/c3Fykp6fj2LFjGDp0qJNGa9z6wgos3lgK0cLjW0WgvKYRclmgQ8dFRETka1w+c3Pz5k08/PDDWL16NUJCQswe+49//AP33nsvXnzxRQwaNAivvfYaRowYgffee8/kOU1NTaivr9f7kppSpbYqsAHaXvggf5e//ERERF7H5Z+umZmZmDFjBqZOndrhsfn5+e2OmzZtGvLz802ek52dDZlMpv1SKBR2j9lQWU2DVYENALQCePD9PKwvrJB8PERERL7MpcHNunXrcOzYMWRnZ1t0fFVVFcLDw/VuCw8PR1VVlclzsrKyoFKptF+VlZV2jdmYuNBuNp3XKgJLNp1k7g0REZGEXJZzU1lZiYULF2L37t3o2rWrw54nICAAAQEBDnt8DQGwevYGAFpEkbk3REREEnJZcFNUVISrV69ixIgR2ttaWlpw8OBBvPfee2hqakKnTp30zomIiEB1dbXebdXV1YiIiHDKmE2xZVlKo5MgIDY0SNLxEBER+TKXLUtNmTIFpaWlKC4u1n6NGjUKDz/8MIqLi9sFNgCQlpaGPXv26N22e/dupKWlOWvYRtm6LNVJEPDGrKGctSEiIpKQy2ZuevTo0W77drdu3dC7d2/t7XPnzkVUVJQ2J2fhwoWYOHEi3nrrLcyYMQPr1q3D0aNHsWrVKqePX5dcFogkhQwllSqj908e2Af7z11DK9qiyUXTExDVMxAQgJEx5neIERERkXXcos6NKRUVFfDz+3lyaezYscjNzcWf/vQnLFmyBAMGDMCWLVtcXuNGqVKbDGwAIMi/M77OmozymkbEhgbh4LfX8Py642gVAT8ByJ6ViNmjo504YiIiIu8liKJoa7qIR6qvr4dMJoNKpUJwcLAkj/nfkstYsLbY7DH5WZMhlwVCqVJj3NK9aNV51TsJAg4vnsTlKSIiIhOs+fx2eZ0bb1DxQ2OHx7y5o60dQ9Gl63qBDfDzjikiIiKyn1svS3mKH39q6fCYLcVXoFLfwr5z19rdxx1TRERE0uHMjQSSFT0tOs5YYOMngDumiIiIJMSZGwk0Nnc8c2PKO78ZjvuTIiUcDRERkW/jzI0EBEGw6Tw/ARgZy63gREREUmJwI4HALra9jIumJ3A5ioiISGIMbiRwsabBpvMe4HIUERGR5BjcSKCfje0XvjpdjbwLNewKTkREJCEmFEsg0N+2l/HPW09BBKsUExERSYkzNxKwtXGmppZfqwgs2XSSMzhEREQSYHAjAbksEE/dGWfXY7BKMRERkTQY3EhkxjC5XeezSjEREZE0GNxIpMGOQn6dBIFViomIiCTChGKJxIV2g4Cf82gslZGqwILJAxjYEBERSYQzNxKRywLxpA15N+sKKh0wGiIiIt/F4EZCj46Pg7WNGFpFMJGYiIhIQgxuJCSXBWLiwD5Wn3ficp30gyEiIvJRDG4kpFSpsf/cNavP+9uOc6xxQ0REJBEGNxIqs7HHFGvcEBERSYfBjYS6+Xey6Tw/AD80NHH2hoiISAIMbiRkS60bzfbx+bnHMW7pXqwvrJB8XERERL6EwY2E4kK7wc/a7VJgjykiIiIpMbiRkFwWiOxZiVa9qIZF/5h/Q0REZB8GNxKbPToa72QMt/l89pgiIiKyD4MbBxgZE2JVMT/NUhZ7TBEREdmPwY0DyGWBWPpQosXHt4rAUxPicHjxJMweHe3AkREREXk/BjcOMnt0NOalxVh8/IeHyhw4GiIiIt/B4MZBlCo1Psq/ZPHx7DFFREQkDQY3DvKHDSesOt5PABOJiYiIJMDgxgFKKq/j0Hc1Vp0zvn8oE4mJiIgkwODGAb46U231OYfP17B4HxERkQRcGtysWLECw4YNQ3BwMIKDg5GWloYdO3aYPD4nJweCIOh9de3a1YkjtkxYsPVjYs4NERGRNFwa3PTt2xdLly5FUVERjh49ismTJ2PmzJk4deqUyXOCg4OhVCq1X5cuWZ606yxTB4VbfY4fmHNDREQkBZcGN7/4xS9w3333YcCAAbjjjjvw+uuvo3v37vjmm29MniMIAiIiIrRf4eHmA4mmpibU19frfTmaXBaIN62ocwO0tWE4+O01xwyIiIjIh7hNzk1LSwvWrVuHhoYGpKWlmTzu5s2biImJgUKh6HCWBwCys7Mhk8m0XwqFQuqhGzV7dDTes6INgwgga2MpSiqvO25QREREPsDlwU1paSm6d++OgIAAPPPMM9i8eTMGDx5s9NiBAwfiX//6F7Zu3YqPP/4Yra2tGDt2LL7//nuTj5+VlQWVSqX9qqysdNSltDMyJsTkfaOM3NcKIP39PKwvrHDgqIiIiLybIIqiYWNqp2pubkZFRQVUKhU2bNiADz/8EAcOHDAZ4Oi6desWBg0ahDlz5uC1116z6Pnq6+shk8mgUqkQHBxs7/A7tGTTCeQWWBdQdRIEHF48iVvDiYiIbrPm89vlMzf+/v7o378/Ro4ciezsbCQlJeEf//iHRed26dIFw4cPx/nz5x08SttF9bQ+QGkRRe6cIiIispHLgxtDra2taGpqsujYlpYWlJaWQi6XO3hUtvn9p8VY9uW3Vp/XSRC4c4qIiMhGnV355FlZWZg+fTqio6Nx48YN5ObmYv/+/di1axcAYO7cuYiKikJ2djYA4NVXX8WYMWPQv39/1NXVYdmyZbh06RKeeOIJV16GUSWV17Hx2GWrz/MTgDdmDeWSFBERkY1cGtxcvXoVc+fOhVKphEwmw7Bhw7Br1y7cfffdAICKigr4+f08uXT9+nU8+eSTqKqqQkhICEaOHIm8vDyL8nOcraC81upzMlIVWDB5AAMbIiIiO7g8odjZnJVQXFJ5HTOX51l8fEpsCP4xZzgDGyIiIiM8KqHYWyUpQvDQiCiLjy8ov46xS/dyGzgREZGdGNw40Fu/TsbWzLGYlRxp0fGiCCzeVMoGmkRERHZgcONgSYoQvDg9AYKFx4sicOwSqxQTERHZisGNE8hlgVj6UKJVAQ4RERHZhsGNEyhVapy/ehOWxCwCgJGxpts2EBERkXku3QruC9YXVmDxxlKLAhsAWHxfAndMERER2YEzNw6kVKmRtcnywAYAhkX1dNRwiIiIfAKDGwcqq2lAq5X5M0H+/JEQERHZg5+kDtTNv5PV5+w5c5VbwYmIiOzA4MaBvjihtPqcd/aeR1o2i/kRERHZisGNgyhVaqw+VGbz+Ys3spgfERGRLRjcOEhZTYNVicSGRABF5SzmR0REZC0GNw4SF9oNfgZV+/wAZN2XoH3RBQCpZmraCJZW/SMiIiItBjcOIpcFIntWIjrdjlA6CQKyH0pEz8Au0C1VfMTE7IwgACNiWMyPiIjIWizi50CzR0djwh19UF7TiNjQIFyt/xHp7+dp2yuYWrYSBGDprEQW8yMiIrIBgxsHk8sCIZcFWlWp+NUHhmD26GiHj42IiMgbcVnKCaypVCwAmDo43NFDIiIi8loMbpxgzeEyiysV3zkglMtRREREdmBw42DW1rs5+F0N/r77HEoquQ2ciIjIFgxuHMyWejfv7DmPmcvz8PtPix0xJCIiIq/G4MbBjNW7sdTGY5c5g0NERGQlBjcOZljvxlpHWaWYiIjIKtwK7gS69W7WFVZga/EVi88dZaaCMREREbXH4MZJNPVuYkODLA5uHhoRhSQFgxsiIiJrcFnKya7W/4ix8b06PO61mUPw1q+THT8gIiIiL8OZGyf6/afF2HjscofHdRIEFvIjIiKyEWdunKSk8rpFgQ0ApA+PZCE/IiIiGzG4cZKC8lqLj91y/AqUKrUDR0NEROS9GNw4SUpsx3k2Gi2iiCJuASciIrIJgxsnSVKE4KERURYfP3/tcSzbedaBIyIiIvJOLg1uVqxYgWHDhiE4OBjBwcFIS0vDjh07zJ7z2WefISEhAV27dkViYiK2b9/upNHa761fJ2Nr5li8NGMQ5k+KR0dl/Zbvv4DnPilyytiIiIi8hUuDm759+2Lp0qUoKirC0aNHMXnyZMycOROnTp0yenxeXh7mzJmDxx9/HMePH0d6ejrS09Nx8uRJJ4/cdkmKEIyKDcHy/Rcs6jm1vbSKLRiIiIisIIiiaG1fR4fq1asXli1bhscff7zdfbNnz0ZDQwO2bdumvW3MmDFITk7GBx98YNHj19fXQyaTQaVSITg4WLJxW2p9YQUWbyy1qpnmSzMG4fE7+zlsTERERO7Oms9vt8m5aWlpwbp169DQ0IC0tDSjx+Tn52Pq1Kl6t02bNg35+fkmH7epqQn19fV6X66iVKmRtcm6wAZgCwYiIiJruDy4KS0tRffu3REQEIBnnnkGmzdvxuDBg40eW1VVhfBw/eJ24eHhqKqqMvn42dnZkMlk2i+FQiHp+K1RVtOAVisjG7ZgICIiso7Lg5uBAweiuLgYR44cwbPPPot58+bh9OnTkj1+VlYWVCqV9quyslKyx7ZWXGi3DpOINaYM6oOtmWPZgoGIiMhKLm+/4O/vj/79+wMARo4cicLCQvzjH//AypUr2x0bERGB6upqvduqq6sRERFh8vEDAgIQEBAg7aDtYOnEzRPj4zljQ0REZAOXz9wYam1tRVNTk9H70tLSsGfPHr3bdu/ebTJHx92U1TRYfOyJy3WOGwgREZEXc+nMTVZWFqZPn47o6GjcuHEDubm52L9/P3bt2gUAmDt3LqKiopCdnQ0AWLhwISZOnIi33noLM2bMwLp163D06FGsWrXKlZdhMc2ylCWzN3/bcQ4PJLHHFBERkbVcOnNz9epVzJ07FwMHDsSUKVNQWFiIXbt24e677wYAVFRUQKlUao8fO3YscnNzsWrVKiQlJWHDhg3YsmULhg4d6qpLsIpcFoilDyVadCxbMBAREdnG7ercOJqr69wAwMqDF5C93bLWChkpCiyYMoAzOERE5NM8ss6NN1Oq1Mi7UAOlSg2lSo03d1jeMyq3oBJjs/difWGFA0dIRETkPVy+W8rbrS+sQNamUrSKgJ8APDE+zupaNyKArE2lmHBHH87gEBERdYAzNw6kqUisCWZaReDDQ2Xws7TYjY5WESivaZR2gERERF6IwY0DGatI3ArgifH9rH7h/QQgNjRIqqERERF5LQY3DhQX2q3dLE0nQcCj42OxOXOsxdWKBQHInpXIJSkiIiILMOfGgeSyQGTPSsSSTSfRIoroJAh4Y9ZQyGWBKLp03Wy9GwHAnFQFxsWHYkRMCAMbIiIiCzG4cbDZo6Mx4Y4+KK9pRGxoEOSyQKwvrMDijaVmz1s8PQFPT4x30iiJiIi8B4MbJ5DLArUzL5ok4442TL254yzG9OvF/lJERERWYs6NkxlLMjamFcDM5XlYttPymjhERETE4MbpjCUZm7N8/wU890mR4wZERETkZRjcOJkmydiaF357aRVKKtlnioiIyBIMblxg9ujotq3gVszg7D1z1XEDIiIi8iIMblwkSRGCWcOjLD7+nX3n2V+KiIjIAgxuXESpUmPz8csWHy+KwOJNpVCq1A4cFRERkedjcOMilu6a0iWKwLFLzL0hIiIyh8GNi5jaNdVRGo5oZUBERETkaxjcuMjBb68ZDVQ6askwMpZF/YiIiMxhcOMCllYp1uUHYOlDbJ5JRETUEQY3LmBLvs2i6QmYPTraMQMiIiLyIgxuXMDaKsUA8ObOs9wpRUREZAEGNy6gqVJsjVYRKK9pdNCIiIiIvAeDGxeZcEefDndG6fITgNjQIIeNh4iIyFswuHGRspoGixOKBQDZs5hMTEREZAkGNy5iad6NAODDeSOh6BXEnBsiIiILMLhxEU3eTacOumdOT4zAk/8uQsbqIxi3dC/7SxEREXVAEEXfqnlbX18PmUwGlUqF4OBgVw8HSpUa5TWNWF9YgS3FV9rdL0C/sJ8gAHmLJ3OJioiIfIo1n9+cuXExuSwQafG9sWh6AgwncQwDG4D9pYiIiDrC4MZNfF5ypV07hskJfYwe61tzbURERNbp7OoBELDywAVk7zjb7vY9Z68ZPV7Ri0tSREREpnDmxsWUKjWWGglszGlsbnXQaIiIiDwfgxsXs6beDQB0EgQW8yMiIjLDpcFNdnY2Ro8ejR49eiAsLAzp6ek4d+6c2XNycnIgCILeV9euXZ00YunFhXaz+Fg/AXhj1lDulCIiIjLDpcHNgQMHkJmZiW+++Qa7d+/GrVu3cM8996ChocHsecHBwVAqldqvS5cuOWnErvXKA0PYGZyIiKgDLk0o3rlzp973OTk5CAsLQ1FRESZMmGDyPEEQEBER4ejhOcWaw2UWHScAmDo43LGDISIi8gJulXOjUqkAAL169TJ73M2bNxETEwOFQoGZM2fi1KlTJo9tampCfX293pe7UKrUWH3IsuDmuUnxKKtpYAsGIiKiDrhNcNPa2ooXXngB48aNw9ChQ00eN3DgQPzrX//C1q1b8fHHH6O1tRVjx47F999/b/T47OxsyGQy7ZdCoXDUJVjNmmTi9/dfYAsGIiIiC7hN+4Vnn30WO3bswOHDh9G3b1+Lz7t16xYGDRqEOXPm4LXXXmt3f1NTE5qamrTf19fXQ6FQuEX7BaVKjXFL96LVyp9AJ0HA4cWTmFhMREQ+w+PaL8yfPx/btm3Dvn37rApsAKBLly4YPnw4zp8/b/T+gIAABAcH6325C7ksEA8Oj7L6vBZRRHlNowNGRERE5PlcGtyIooj58+dj8+bN2Lt3L+Li4qx+jJaWFpSWlkIulztghI6lVKmx+fhlm85tbL4l8WiIiIi8g0t3S2VmZiI3Nxdbt25Fjx49UFVVBQCQyWQIDGxbcpk7dy6ioqKQnZ0NAHj11VcxZswY9O/fH3V1dVi2bBkuXbqEJ554wmXXYauymgarl6Q0OHNDRERknEuDmxUrVgAA7rrrLr3b16xZg0ceeQQAUFFRAT+/nyeYrl+/jieffBJVVVUICQnByJEjkZeXh8GDBztr2JKJC+0GPwE2BTijYkOkHxAREZEXcJuEYmexJiFJSkqVGmU1DYgL7aaXCLy+sAJLNp1EixU/hodGROGtXyc7YJRERETuyZrPb3YFd4L1hRXI2lSKVrGthUL2rERtpeHZo6Mx4Y4+WHO4HKsOXezwsf45bySmDPKOAoZERESO4Ba7pbyZUqXWBjZA2xLUkk0n2xXj+/Bwx4GNAGBwpMwBoyQiIvIeDG4czFjSsOFWbksTi0UAX5xQskoxERGRGQxuHEyTNKyrkyAgNjRI+303/04WP95fvzjDKsVERERmMLhxMLksENmzEtFJaItwOgkC3pg1VC+p+IsTSqses1UEsjaWcgaHiIjICCYUO4Emabi8phGxoUF6gY01zTN1tQJYc7gcS2YMknCkREREno8zN04ilwUiLb53u35Q1jTPNPTh4YucvSEiIjLA4MbFjOXkWKpVZKViIiIiQwxuXEyTk2PrDyLInz9CIiIiXfxkdAOzR0fjnYzhNp27+mAZl6aIiIh0MLhxEyNjQmxantpWquTWcCIiIh0MbtyEXBaIB4dH2XQut4YTERH9jMGNm1Cq1Nh8/LLN52u2hhMREfk6BjduoujSdYtaMJiz+hC3hhMRETG4cQPrCyuwIPe43Y8jgrM3REREDG5cTNM13M5JG63Vhy6ipPK6RI9GRETkeRjcuJilHcEtJQJIfz+Pu6eIiMhnMbhxMXsqFJsicvcUERH5MAY3LmZvhWIAMBYbcfcUERH5KgY3bsCeCsUAMDM50ujt3D1FRES+iMGNmxgZE2J0BsYSn5dcQUaqot3t3D1FRES+yKbgprKyEt9//732+4KCArzwwgtYtWqVZAPzNXJZIBZPT7Dp3FYRGNsv1GhwxNkbIiLyNTYFNxkZGdi3bx8AoKqqCnfffTcKCgrwxz/+Ea+++qqkA/QliX1lNp3XSRAwMjYET94Z1+4+zt4QEZGvsSm4OXnyJFJSUgAAn376KYYOHYq8vDx88sknyMnJkXJ8PsWWnVMCgDdmDYVcFohHx8eZnL1h7RsiIvIVNgU3t27dQkBAAADgq6++wgMPPAAASEhIgFKplG50Pkazc6qT0BaidBIE3Dc0wnwujs6dclmgydmbmcvzsPLABUnHS0RE5I5sCm6GDBmCDz74AIcOHcLu3btx7733AgCuXLmC3r17SzpAXzN7dDQOL56EtU+OwdKHhmL7ySqz1YsNa9o8Oj7O5OxP9o6zWHmQAQ4REXk3m4KbN998EytXrsRdd92FOXPmICkpCQDw+eefa5eryHpKlRp5F2pwtf5HvL//PF7cUGrRebo1bTqqm7N0+1kmGBMRkVcTRFG0qfh/S0sL6uvrERISor2tvLwcQUFBCAsLk2yAUquvr4dMJoNKpUJwcLCrh6O1vrACWZtKbW7F4CcAXy+eDLksEABQUnkdM5fnGT32qTv7YcmMQbYOlYiIyOms+fy2aeZGrVajqalJG9hcunQJb7/9Ns6dO+fWgY270jTPtKfHVKsIlNc0ar9PUoQgy8TWciYYExGRN7MpuJk5cyb+/e9/AwDq6uqQmpqKt956C+np6VixYoWkA/QFUjTPFAQgNjRI77anJ8abLO7HBGMiIvJWNgU3x44dw5133gkA2LBhA8LDw3Hp0iX8+9//xjvvvCPpAH2BFM0zM++K1y5J6VoweQATjImIyKfYFNw0NjaiR48eAIAvv/wSs2bNgp+fH8aMGYNLly5Z/DjZ2dkYPXo0evTogbCwMKSnp+PcuXMdnvfZZ58hISEBXbt2RWJiIrZv327LZbgNwy3gtujRtYvZx2aCMRER+Qqbgpv+/ftjy5YtqKysxK5du3DPPfcAAK5evWpVku6BAweQmZmJb775Brt378atW7dwzz33oKGhweQ5eXl5mDNnDh5//HEcP34c6enpSE9Px8mTJ225FLehuwV8/qR4q883Nwsze3Q0NmeONXqfCODdPeetfj4iIiJ3ZdNuqQ0bNiAjIwMtLS2YPHkydu/eDaBtJubgwYPYsWOHTYO5du0awsLCcODAAUyYMMHoMbNnz0ZDQwO2bdumvW3MmDFITk7GBx980O74pqYmNDU1ab+vr6+HQqFwu91ShraduIL5ucetOkcAkJc12ejyFACsPHAB2TvOGr0v674EPD3B+qCKiIjIGRy+W+qXv/wlKioqcPToUezatUt7+5QpU/B///d/tjwkAEClUgEAevXqZfKY/Px8TJ06Ve+2adOmIT8/3+jx2dnZkMlk2i+Fon2CrTtShBgPUMwRARy7ZHoXlKkEY6BteYo7qIiIyBvYFNwAQEREBIYPH44rV65oO4SnpKQgIcHGztatrXjhhRcwbtw4DB061ORxVVVVCA8P17stPDwcVVVVRo/PysqCSqXSflVWVto0PmdraG6x6byO5uEWTB5gtJ0Dd1AREZG3sCm4aW1txauvvgqZTIaYmBjExMSgZ8+eeO2119Da2mrTQDIzM3Hy5EmsW7fOpvNNCQgIQHBwsN6XO9NUKVY3/2TT+Ype5md85LJALDZR/wbgDioiIvJ8nW056Y9//CP++c9/YunSpRg3bhwA4PDhw3j55Zfx448/4vXXX7fq8ebPn49t27bh4MGD6Nu3r9ljIyIiUF1drXdbdXU1IiIirLsIN2RvlWIAePD9PGTPSsTs0dEmj3l6YjwgtC1FGXuqpdvP4oGkSJO5O0RERO7Mppmbjz76CB9++CGeffZZDBs2DMOGDcNzzz2H1atXIycnx+LHEUUR8+fPx+bNm7F3717ExbXvaG0oLS0Ne/bs0btt9+7dSEtLs/YyXEIzM2O4/VqKKsVAW6XiJZtOdri9++kJ8dhiZgeVplcVERGRp7EpuKmtrTWaW5OQkIDa2lqLHyczMxMff/wxcnNz0aNHD1RVVaGqqgpq9c8fzHPnzkVWVpb2+4ULF2Lnzp146623cPbsWbz88ss4evQo5s+fb8ulONX6wgqMW7oXGauPYNzSvVhfWKG9T4oqxRotoqjXisEUtmggIiJvZFNwk5SUhPfee6/d7e+99x6GDRtm8eOsWLECKpUKd911F+RyufZr/fr12mMqKiqgVCq1348dOxa5ublYtWoVkpKSsGHDBmzZssVsErI7MJyZMZxhkaJKsYaA9q0YTGGLBiIi8jY21bk5cOAAZsyYgejoaO1yUH5+PiorK7F9+3ZtawZ35Kqu4HkXapCx+ki729c+OQZp8b0BtM3sLNl0Ei22NWrX8+ZD5vNudClVaoxbutfkzFHmpHi8OM22XXBERERScHidm4kTJ+Lbb7/Fgw8+iLq6OtTV1WHWrFk4deoU/vOf/9g0aG9nbGamkyDozbBoqhS/N2c47OjEAABYvKnU4rYKHbVoWL7vAndQERGRx7Bp5saUkpISjBgxAi0tttVocQZXzdwA+jMznQQBb8waanJ2ZX1hBbI2lsK2jfVtlmcMx4xhkRYfX1J5HTOX5xm9r6Pqx0RERI7k8Jkbso1u/6jDiyeZXTaacEcfvDxzsNGCe5b6+vwPVh1vLsFYBPD6tjNssklERG6PwY2TyWWBSIvvbXYGRLOr6s9bTxutQ2OptQUVVgcjT0+MR6aJxp3bSpXtdnkRERG5GwY3bkaqejdAx72mTHlxWoLJHlStIpC10fJ8HiIiImezqkLxrFmzzN5fV1dnz1gI0ta7AYDdp6utyrvRWDB5ANYVVBodSyuAd/ecxxuzEu0fIBERkcSsmrnR7a5t7CsmJgZz58511Fh9gpT1bgBgS/EVm2ZZOtpBlVtQwR1URETkliTdLeUJXLlbylJS7JTS9eK0O5A5aYBN5ypVary+7Qy2lSrb3ScA2JI5FkmKEDtHSEREZB53S3m42aOjseg+6YrmLdv1rc2VhuWyQPzx/kFGd22xijEREbkjBjduSKlS480dZyV9zOwdZ21eRpLLArHYxBZxex+biIhIagxu3JDUScUa2dvP2rzL6emJ8ci6L8Fk3Z2ldjw2ERGRlBjcuCGpk4p1vbD2uM3nPj0hHlsyxxq9T0TbDioiIiJXY3DjhjraqWSPI+XX8b+7bF/yMlfFOLegAks2n+AMDhERuRSDGzc1e3Q0fmOikJ693tt3wa4A5OmJ8SaL/OUeqWQVYyIicikGN25KqVJj7ZFKo/ctzxiOX42Msuvxf/1BPkoqra9erLFg8gCT+TesYkxERK7E4MZNldU0GO0rlZESjRExIdhQdNmux6+8rsbM5Xl49uMim87vaAeVpooxERGRszG4cVOmkorXFVZgzeEyuxpq6tpxssrmHJyOdlCxijEREbkCgxs3ZSqpuFUEVh0qk/S57MnBeXpCPPKyJuP+RLnR+5duP2vX8hcREZG1GNy4sdmjo/FOxnCnPNejawptDnA6qmKc/n4eE4yJiMhpGNy4ucAuzvkRna26gbTsvXa1aTCVgyMywZiIiJyIwY2bu1jT4NTns6eVgrkcHCYYExGRszC4cXMpsb2c/px2tWkwU8U4t6ACy+woIEhERGQJBjduLkkRgulDI6w6p0dAJ7uf9292NO5MUoTgqTvjjN63fN8FVjEmIiKHYnDjAVb8diTSkyMtPv5GU4vdz7m5+IpdQcij4+NMbxE/UomxduT3EBERmcPgxkMMkgc7/Tlzj1TanGTcUZE/Efbl9xAREZnC4MYDKFVqvLnTumWih1OjJessnr3jrE25Mk9PjEfmpHizxyy1I7+HiIjIGAY3HqCspgGtVpYkvlhzE5ufM57Yawtbc2VenJZgtoqxCGDN4XJ7h0dERKTF4MYDdPO3PkE4/0ItlmwqlXQctubKaKoYZ6REG71/9aGLrGJMRESSYXDjARqabUsQPqW8YXLGxFaaXBlrl6nkskC8MSsRGakKo4/JKsZERCQVBjcewFQTTUtI1WDT0PJ9F/CXrSetPm/B5AFGr4VVjImISCoMbjyApolmJ0HqeRj7fJR/CY/mFFh1jqmGoEBbFWPm3xARkb1cGtwcPHgQv/jFLxAZGQlBELBlyxazx+/fvx+CILT7qqqqcs6AXWj26GismjvC6H0CgCwz264dad/Za3jx02Krzpk9OhqbTVQx/vDwRc7eEBGRXVwa3DQ0NCApKQnLly+36rxz585BqVRqv8LCwhw0QsdQqtTIu1Bj9Ye4qT5TkxPC2vo6uSjA+ezYZdz9f/vxn2/Kse3EFYuuy1QV41YRKK9pdMQwiYjIR3R25ZNPnz4d06dPt/q8sLAw9OzZ06Jjm5qa0NTUpP2+vr7e6ueT0vrCCmRtKkWrCPgJQPasRMwebXwXkSFTfab2nL2K/+SXIyokUMqhWuW76ga8tOWU9vvMu+IxbkAo4kK7QS4zPq5Hx8fhw8Nl7ba5n7hch7T43o4cLhEReTGPzLlJTk6GXC7H3Xffja+//trssdnZ2ZDJZNovhaL9bh1nUarU2sAGaJulWLLppMUzOGerbpi876WtpzA/97jku6NstXz/BWSsPmJ267hcFohF97afbXqThf2IiMgOHhXcyOVyfPDBB9i4cSM2btwIhUKBu+66C8eOHTN5TlZWFlQqlfarsrLSiSPWZ6wYX4soWrQMowmMOuKo3VG26mjreGJfWbvbWgG8vu0MAxwiIrKJS5elrDVw4EAMHDhQ+/3YsWNx4cIF/N///R/+85//GD0nICAAAQEBzhqiWZot3boBTidBQGxoUIfn2lKl2J0s33cBN3/8CdOGRugtVcWFdoOA9kHZtlIltpUqkZGiwIIpA0wubRERERnyqJkbY1JSUnD+/HlXD8Mihlu6OwkC3pg11KIPbktr3QiAZD2lpPZR/qV2S1VyWSCeNJJYrJFb0FYVmQX+iIjIUh41c2NMcXEx5HK5q4dhsdmjozHhjj4or2lEbGiQxTMSmsAoa2MpWs0ct/ShRADo8DhX0ixVXalTY1RsCIKDuhidvdE9fvHGUiRE9ECSIsR5AyUiIo/k0uDm5s2berMuZWVlKC4uRq9evRAdHY2srCxcvnwZ//73vwEAb7/9NuLi4jBkyBD8+OOP+PDDD7F37158+eWXrroEm8hlgTYts2gCozWHy7Hq0EWjx1TUNuLFaQnoFtAZ83OP2ztUh/oo/xI+yr9k0bEigJnL87hMRUREHXJpcHP06FFMmjRJ+/3vfvc7AMC8efOQk5MDpVKJioqflyOam5vx+9//HpcvX0ZQUBCGDRuGr776Su8xvJ1cFogunUyvOy3fdwHBgV3wQFJku/web5BbUIncgko8dWccHh0fxyCHiIjaEURR9LKPP/Pq6+shk8mgUqkQHBzs6uFYTalSIy17r9lj/ATg68WT8XnxFWTvsK7BpSextk4QERF5Lms+vz0+odjXlJmoUqxLU+XX2DZrb9LKZptERGQEgxsPY8muKc32cnu6iXuKVgDv7vGM3XJEROQcDG48jCUdwv/fmGht0rKxCsACgHsHh5t9nrAe/vYO1Sr9+9geiOUWVGDlQeNVkImIyPcwuPFAs0dH4w/TB5q8Pyf/krYujLGlKRFAdO9uSI0zva366o1mhDsxwDl/ra1IYUaKAvMnxVvdRmIpWzYQEdFtDG48kFKlxtLt5hOFF9/ORdFUADa0+tBFPDWhn9nHqL7RbMcobZNbUIkbP/6EV2YOtuo8EcCbO84i70INSiqv6/2XQQ8RkW/x+CJ+vqispqHDHlIigKLy67g/KRJP3hmHVYfK2t3/xL+L8NCIKGw8dtlRQ7WJpbVvDG0pvoItxVfa3S4AeM6CLuXeQqlSo6ymwSeulYjIGM7ceCBTszGGNGk5j46PM5rPIorA5mOXsTVzLAbLPW9bvKVE/NylfNxS723loFSp8foXpzFu6V6vv1YiInMY3HgguSwQSx9K7DDA+b5OrT0+e1ai0R92K4D1hd9j+8I7MUTeQ7IxRocEWp034wytIrBk00mvWqpSqtRYsukE0rL3YvWhMm3hRm+8ViIiSzC48VCzR0dj8X3td0Lp0k2ynT06Gpszxxo9LregAks2n8AbsxIteu5e3bp0eEzFdTVEANMGheOZiaYbY7pCiyiiqPy6pI+pVKldkt+zvrACadl7kVtQafT+FlFEeU2jU8dERORqDG48lFKlxpsdVB8WAaw5XK79PkkRgqdMdODOPVKJB9/Pw0Mjojp87tqGWxaPc9eZahSUX8eTd8a51UzOgrXHJVuyWV9YobcUtPLABacEOkqVGos3lnZ43InLdQ4dBxGRu2Fw46HKahos6hu1+tBFvQ/ZR8ebDjJab+fg/HPeSEkDkWOX6rD6UBlEwOz2c2cSASzaWIr/5JfbFYQoVWpkbSrVWwrK3nEWGauPYGx2W6DjCEqVGn/ddrrDxHIAeJPb5InIxzC48VCWJhUbzt7IZYFYPN30clYrgCMXr5s9xh5Hyq7jnsHhmDbEfBFBZ3lp6ymk2RCEKFVq/LfkMv60+aTJIFNEW6CzcN1xSYOL9YUVGJu9F1+UVll0fCuA17edYYBDRD6DjTM92MoDFyxqjCkAyMuarLcteOXBC1i6/azRv/wFAO9mDMf83OOSjdWYaYPDsOv0VYc+hzXuGRyOV2YO6XD79PrCCizeWGrRrImujBQFxvYPxciYEJu3aCtVaoxbutembu9sNEpEnsyaz28GNx5u2a6zWL6v41mHp+7shyUzBundplSp8fq2M9hWqmx3fHpyJLYWX7H6A9wbZKQoMCgyGCFB/nqBiFKlxtHyWixYW2z3c2TaWHfnjS9Ot6tZpCEA2JI5Fl+cUHZ4TJLCPZYHiYgsxeDGDG8LbvIu1CBj9ZEOjzM2ewO0fWCPzd5rNIhJiOiOs1U3pRmoB8tIUQCCgHUFFTbNmFjy+AumDOgwyDH3s9KdlbFkdidregKenhhv38CJiJzIms9v5tx4OFtzbzTkskA8aWIHFQObNrkFlcg94pjARvP4luT9mKpMfX+iHF8vnqxdbjJX10gje8dZNhslIq/F4MbDdZQgrGv1oYsoqWxf38XcDipynuwdZ7Fk8wmTib9xoe07p/sB+OP9g9rN+sweHY2vsybj/kS5yedbuv2s0fcDEZGnY3DjBR5IjrR49mbm8rx2MwTWBEjkWLlH2mZxlmw60a7x58Fvr0F3EVkQgOyHEk0uZ8llgfjj/YNMvjc074clm0wHVNZyVTFDIiJdzLnxApbm3ejKui8BT0/Qz7kwt4OKLCMADnn9pg0Ow5enr+o9th+Ar43kURlaX1iBRRYU+7N1N5emUWfpZRXe3HEWrSJ3ZhGR9JhQbIY3BjfmEk1NMZdg/O6e88gtYMNFWyQrZCiuVHV4XHpypNEO5tZa++QYpMX37vA4zc91bUGFRe8TcwnHml1jgiDgcp1aG9AY6iQIOLx4EjuTE5EkmFDsY2xZVhIBvLvnvNHHemNWIjIncSeNLSwJbAAgKiQQ+VmTkZESbXO+UydBQGxokEXHan6uW0z0FzOUveMslu1qX0NJU0BwwdpizM89juztxgMboK2v1Venq7lMRUROx5kbL6FUqZGWvdfq8zJSFVgw2fg2ZFuWqfwAbM4ci/WF31s8S+CrMlIVmD1KgYraRuw9cxWbrZjJsWfZx9LijwCQnizHyNheCAnyhyIkEOnL82z6mQoAFnP7ORHZgctSZnhrcGNL3o2GuQ8eW5apRsX0RGJUT0T27IrXt1v2IerrrMnVkaIQn6vyqzInxePFaUxeJyLrMbgxw12CG00SprUVas09nrV5N4bMffAw2dg2qXEhKCi7bvXrJgCYNzYGH+Vd0jtXEIClEiXqKlVqFJVfR/7FH/DJEeflWDHAISJbMLgxwx2Cm/WFFdpO0lLuKrFmucEUc8tUmg/DPWeqrVpCkdod4d0xOaEPDn5bg9PKGy4bhzVSY0NwpNy6mjLPT+6PKYPCUFmrRp26GSFB/hhhR18qc5SqtsRgKZKcLZGeLMfUwRF29dkiIt/C4MYMVwc3xkrjS7WrxJ6lKV2W5EdY2tPKkQbJeyC6VxB2nap26TgsNTKmJ4ou1Vl1jgBg6UPGg1/N7F83/06oqG1EnfoWACAkyB+BXfxQXFmHgM6dEBvazWgQoTt7CLRVQM47X4Pl+y5YPNPkJ6AtSAfwxIQ49O4eYPUMn619tjSkngUlIvdkzed3ZyeNiW4rq2lot7ukRRRRXtNo9y9mTQVbe9sEiGjbLXNaWY/F0xOMjkuzrODKAOeM8gbO3J65iQsNwtDIYCTIg3HiexW+PFXtdkto1gY2QNvPYvHGUiRE9NDLsVl58AKW7jgLS/80MQySdGcPNbu1xNvHzUlRQBAE5B4xnxDuJwCbnxuLxuZWxIYGad8nDyRFoqj8OgQBKCyrRU7+JbNjW77/Apbvb3sfWTuj46hZUCLybJy5cTJHztwAt3/ZbyxFq92P9DNzxd1WHrxgss6Jq2h2+PQK8kfXLn54/KMiVw/Jbrq5NrbOmmkSkcOCu3bYWNNPABbdm4ConoGoUzfjjPKGXrBjTe6PreN96s44PDo+zuS/C1P/ljY9l4aK2kYIgsBlLyIvwmUpM1wd3ABtAciSTSfRIoroJAh4Y9ZQSf/a3HbiCubnHrfo2NS4Xigoq7V4lsPYEoJSpUZ5TSOC/P1w4nsVPi++gqOXrE+idYSMFAV6dfPHey5eQpPKtMHh2HXavmW4YVHBOHG5vsPjDINuTc6VIMDq3B9bE9I1S6QPJEdqCwdqAhZL3ufmlvWIyLMwuDHDHYIb4OeAQHc6X8rHtqbmzdbbdWmsrUqckaLAgimmk4/Laxrx8Tfl+KK0yqrHJfdhaQVkSyhVaqw5XI5Vhy7a/Vj3DY3A9pOWva/8BODrxR23qSAi9+YxFYoPHjyIX/ziF4iMjIQgCNiyZUuH5+zfvx8jRoxAQEAA+vfvj5ycHIeP0xHkskCkxfd2yC9cuSwQGSkKi49ftLEUC6b0t7oqcW5BW5PHlQcutGuYqLm+5Q+PxH2JEVY9LrmP/564LFl1YbksEEtmDNJWZjbscG4NSwMboC0Hrbym0fYnIyKP49KZmx07duDrr7/GyJEjMWvWLGzevBnp6ekmjy8rK8PQoUPxzDPP4IknnsCePXvwwgsv4IsvvsC0adMsek53mblxNGtnbzQ5FHXqW3bVsxEAPHdXPBLkPfSWEEoqr+O1badx1IakWmeaNigcocEBWFtQoU22TbGxVo23MJaoa26nlqV5LprZva/PX7Nqh5a1BACvpg/RVlluaG7hzioiD+SRy1KCIHQY3CxatAhffPEFTp48qb3tN7/5Derq6rBz506LnsdXghsAWLbzrHYXiiU0XaYBSFrcTXf56tGcAuw7e83s8Zl3xeN64y2XNe+clxaDUbEh8BMEbW6JJt/kqzPV2Fp8xScDnddmDsGwvjKsL6zE2oJKs69BRx3GDbdva17fOnUzisqvO7yOEndWEXkerw1uJkyYgBEjRuDtt9/W3rZmzRq88MILUKmMNyxsampCU1OT9vv6+nooFAqfCG5sqXvz1J39sGTGIO33mvYL6wor7N4RlZGiwKDIYGwtvoKjJgra3TMoHA8Mj8QZZb3L6+gY+wAsqbyOmcvzXDgqz2OYhG7J9m1n1FGSoo0FETmP1wY3d9xxBx599FFkZWVpb9u+fTtmzJiBxsZGBAa2/wvx5ZdfxiuvvNLudl8IbmxtyZCf1T75UncJwVt2HlnqmQlx6B7YBfkXfsDX539w9XA8WnqyHJ+XKC0qhaBbZsAPwDCFrF3XdQHAa+lDkBglw4Pv59kUgNtbRJCInIPBjQ5fnrkBbGvJMG1wOFbOHWXyfs1sDrt+67Om+SXp+//uuQMxvYP0cncUIYGoqG3UWx7UDXgMyyjolljwA6yu9cSlKiL35rUViiMiIlBdrV/jo7q6GsHBwUYDGwAICAhAQECAM4bnlp6eGI/6H29ZNcW/63Q1Hs0pwJpHUozeL5cF4o1ZiVgwpT/WHC7Hh4cvulURP1fISFGgsbnFab2ZvM3/fvmt2fszUhSYPVqBxCiZ0arIADB7dDQm3NFHW3PJ2pmcVhHIul0NmknHRJ7No2ZuFi1ahO3bt6O0tFR7W0ZGBmpra5lQ3IGF645jq5UfvL8aEYVlv07u8DjdIn6Nza0I8vfD+sLvObNjhxen3QFZYBeo1LewbJf5D35fpGnToJndqVPfardTS3cmRwAwM1mOLcVKi5+DMzlE7sVjlqVu3ryJ8+fPAwCGDx+Ov//975g0aRJ69eqF6OhoZGVl4fLly/j3v/8N4Oet4JmZmXjsscewd+9ePP/889wKbgFrt4ZrJCtkWPHbkTY3NNTsuuqoTxHp021vsL6wAos3lvL1s5AmcV2jl0439fWFFVi0sdTM2foEAK/OHIKpg8M5i0PkYh4T3Ozfvx+TJk1qd/u8efOQk5ODRx55BOXl5di/f7/eOf/zP/+D06dPo2/fvnjppZfwyCOPWPycvhrcAMD8T4qwzcZqwVkddAnviO5W3zPKG9o6MmSaJtEWAHafrsLnJVdwtLzOtYPyQIYtGGzZAcg2DkSu5zHBjSv4cnBj7zbmzEnx2m7g9tJdyqqsVUMQgL4hgVhf+L0k2869xaiYEBS5SZ8uT/f/3XMHYkO7aQv5qZt/QkmlCu/sPW/zYzAvh8h5GNyY4cvBDQA8+3ERdlhRut7QvLQYTBsa4dBf6s6qXEskBXM91ohIOgxuzPD14AYAXt56Ejn5l+x6DE23ZnuWqiyhm7fDpSzvM65/L9w7RI7q+h/x/v4LHv3zzbrdvVy38jIRSYfBjRkMbto8nlOAPR20QbCEM2ZyNAx3ZZ2/egMvbT3l0Ock58m8Kx7jB/TBict1yN7ecW2mF6fdgfH9Q1FZq9bmcrlL4rqmxxqLAxJJh8GNGQxu2kjdRsBZMzm6lCo1xi3da/Kv/YxUBRZMHgAAWHukwqrcCtL3i2EROF5Rh+/rfnTo82iCZXXzT3j8oyKzxxpL8tVNXHeXbfSafxuc1SGyD4MbMxjc/OzXH+ShwESPJ1tJmXRsCd1aJoY0jUA1jRnNBULkfpKNtFsw5jWdrdpKlRpHy2u1Helf23Ya223cISg1TQVr1s8hsg2DGzMY3PzM1to3HUlPlmNkbK92RdUcRalS44sTSvz1izPt7stIicaCKf1xtLwW+Rdrse523k4nQcC0IeHYeaqKAY+XmDSwD/ads3+p1Rn8AGxm004iqzC4MYPBjb5lO89i+X7HNsJ0RmNCa5qEPjUhDo+Oi9P+pW/Pzqz0ZDnuHhyBrl38UFbTiEPfXcOBb2tsuQSvM21QOEKDA/DJkQpXD8WkZybGoVrVhM0uaJvB2jlE1mFwYwaDm/Zmr8zDkTJpl6eMcXRezhtfnMaqQ2UdHucnAF8vNt75vKj8OgQBKCyrtXhHWbJChpJKlVsksrqbjBQF4kK74XULEoSdyXBpSLchp7O9lzGcdXOILMDgxgwGN+0pVWqMXboXznonOGqHlTWzN2ufHIO0+N5mj1m266xVDUfJM5haEnKX+krcUk5kHIMbMxjcGOeK/kWOmMlZeeACsneYnyUwNXNjDAMcx5iZHInHxsWislaN/Is/OG3pqpMg4I1ZQztcCtLM4l2qbXDpjivNDNOEO/ow2CGfx+DGDAY3pkm9PdxSmZPi8dsxMThaXqvt7qzp9qzZ9WLNL/SVBy9g6fazRgM1W/IczD2eq8xIjMCf7h+sXUb7olTpNruCrBEXGoShkcEYGBGM81dvYmvxFYe9zgKAD+eNxJRBEVadZ0nA7GiCAIhi2zU8eWccHh0fBwAMeMinMLgxg8GNeZbmrTibtSXulSo11hwux4eHL6L19ofCHDvK5Bs+nqsZW1b7T365xxc1zEhRICokEDU3m3Hx6k0c+E7a5Gxbk3jdbQZPuP1fzVsxI0WB2aMVzNshr8bgxgwGN+ZZk7fiCk/d/qvVmiCnvKYRsaFBkvzCV6rUeH3bGWwrVdr9WLbSrd+ji7V8LJdv5PXriDvO4BnDooHkraz5/PZz0pjIBKVKjbwLNVCq1K4eCgBALgvE0ocStX8ZWmOIPBh+tpxohVWHyjA2ey9WHrDsr2i5LBBp8b0l/eX+hYnARnPtnQQB9w1tv/QhCG3JounJkXY9fyuAz41sXZbLApE9K5H/qC3wp80n9f7NWfLv8OkJ8cjLmoyn7uxn9fM5+J+FHhFA9o6zSMvei4zVR6z690LkLThz40LrCyuQtakUraL7VS1VqtT46nS11csc9w2NwIiYEJyrqsdnRZcdNLo29u66UqrUVv9lm3ehBhmrj7S7fUpCGDJSFSiraYQssDNe3FDa7hgBQN7tGQMpth7rVoPWXEs3/05Yvu88vjx91fYH9iEZKQr06uaP5fsvtMtpMfeeKKm8jvTlee1mcZIVMpz4XtX2bxrAE7drKgFAeU0jGptv4YmPilwy+zMvLQajYkNsymMjcgdcljLDXYIbY0sInQQBhxdPcqtfOrYmUwoAxvTrhfyLtdIPyoj0ZDmmDo7QJiIbJiZrvtf8Ul958AKW7jir/UCbk6LA2P6hHf7St3fpRzdXRrcR6PrC77Gu0Pqu5/PSYnCrpRVrCyqd+oH5x/sSIJcF4qsz1djiggJ4jmbJHxu6rT/8ACy6vfOvo6VQ3fM6CQKemdgPvbr5I9hEUOwomn8zDHTIUzC4McNdghtTMwCW1F9xtiWbTyD3SKVN5469HeC405ssrYOgK6uD7enrCyuQtbEUrVY+r7nigZpZl8bmVjQ23+qwaaSraWaqnvh3kdPqIzmbJX9s2JrTZeo8V5RkAKxP2CdyBQY3ZrhLcOMpMzeA/UnG9wwOR58e7l2G31BHDUC3nbiC+bnHLX48QQCW3p4J0G3ueFZZr10S0Z0tWF9YgUUbnfdXPBn3/OT+mJMa7dR/k7o1dvadu4qj5XVOe+70ZDn6h/fADzeb0bubP2RBXaBS38IPN5vRL7SbtkEpkSswuDHDXYIboP30tCXFxVxFilofGSkKNDa34POSKx6xoycjVYEFk43/NWtNwPfX9CGYMihcuxyWbaYVgWEn83f3nLdpuYqklXlXPMJlAai52YykvjIE+ndGXGg3AI6vNfPcJ0VuVcNo3pgYTEuUvsI4UUcY3JjhTsENIP1WZUeSaits5l3xGD+gjzbXZG1BhVstW+kyV0XZkiWEjJRopMX3Qp36ForKr1uUn5KREo03ZiVqv9e8RzxhucqXWVumwBolldex98xV+Hdp2wv3v7u+dYt/M+Pie+HeoXLO6JBTMLgxw92CG08jVRXjsfG9sejegUhShGin4Z1Zht9ammUq3SUlRUgg/vV1GbYWS1/zJuu+BDw9oX1A1dEMWuZd8RgkD4YgACNiQvB5yRVt4jQ5x5SEPrhrYJhDP/B1Z33dxbj4XkiLD0VsaDcmKZNDMLgxg8GN/aQsRx8fGoQHR/RFbGg3KEICUfJ9Hb48VY2vL/zglA/klNgQ/HHGIKz5urzDWZVkhQzFlSrHDwrm+1+ZSvBOT47ElEFh2p1hZ5X1eM+Nqur6oo6S0y1lrGyBZkbvxOU6vLn9rNUJ7o6mG+QB0P5RwMCHbMXgxgwGN9JwRjn6jBQF/Dv5ISf/kkOfR7P0BAFuVYH2vTnDcX9S+4J/7l5FmvTplimwtD2CZoawTn0LZ5Q3sK7g57wrYzubSiqvI/39PI+ZodPM3IYFd2UVZbIYgxszGNxIR4pCdB3JnBSP4MAuTgk6NA08391zHrkFjl8e0/QDWl/4vcnnM7VF157t+eRa5uoqKVVq/OtwGT48VNbh+z3D4DGkWqqK6RWIilq19vmHyHvglPKGXY9piZlJkXhsfCz7Y5FJDG7MYHAjLc3U+PrCCocVc0tPlmNkbC8IAEKC/NE3JBCVtWrUqZsBAH/aIl2zSM1f2UfLah02Y2SsyWFHydoZKQoMimx7v55R3kCum+YmkfUy74pHgrwH9py5avO/oazbvaSOltdCpb6F08obWHvE+kR9AfrNODWBtVKlxsai7/G/X35r0/hswWagZIjBjRkMbhzDWUslmXfFY9yAUL1fdo5qaKgICUTldWl6fhn+Naz5ENHdjWVt7RwiXbqBieb7lLgQFJRft3m5asKAUNw9JFxb3fvgt9dcUmQQYKFBYnBjFoMbx7Ek0XhUbE/c+qkVJd/X2/18GSkKxIR2s3ppLD1ZDgECNts50zShfyhaIeLw+R/sehygbXfUA0mRDg8QJ94RigPf1jjwGcib3TMoHHcODNXOoo6ICQEAvLnjrNPacPxyeBR6BHZGQ1MLEvvKMKyvzGiLFfI+DG7MYHDjWNbMooyK6QkBAgovXXf4uHRpKkF//M0lhydFW0rTVPPz4iuS7URzpujbs1w+9cvEx01J6IPh0SGIDe3mdjvzNEvZmmAHcHyxRXI8BjdmMLhxPE1lXUuTcjNSFPjhZjN2na528Mh+punh5aglLVvcnyjHH+8f1Fabxk3GZKmn7uyHR8fHahuBNja34uvz1/D+/gusrkwuZ2wZGDC+xZ7cF4MbMxjcOI8128UFAHcN7IP956455UNdt0ieUqXGmsPlWHXoohOe2TxNf6kJd/TRFjbMNZEYmpGqQLWqCXvOXpXs+TNSom3eKfZexnCju380Fbg9MWgj7zQsSoaQoC44+F2N9v3IthLuj8GNGQxunMvamZFfjoiC+lYrviiVvuqvLs0ykOEH8bt7zru8HYQAYEvmWIQFd8XR8lpcqm1E7c1m+HcW0PSTiPg+3TBlUFthNKlzdPwEYNG9Cbj0Q6NNr4O5dhXAz4Hkh4cvckbHTbw47Q5U/NCIxuafcL3xliQ5ZJ5uQv9Q/DpFYXH+ju4MEMAlMEfxuOBm+fLlWLZsGaqqqpCUlIR3330XKSkpRo/NycnBo48+qndbQEAAfvzxR4uei8GN89k6M5KskOHE9yqHfQjGhwbhkfFxCAny1yuwBgBF5de1LQx0vz9jY26BAOC19CFIjJKhsbkVQf5+ePD9PJuvTVPjxNbdVX4A5o6NwUd5l9oFMJrmnQDaBSKGO3JM6airulKlxhcnlPjrF2dsGL3zjIvvjYzUaHTt4oc1h8vbKme7elASu2dQOEKDA/QKBY6K6Yn4Pt1RVf+jzyegD5H3wPDonujVPQCKkEDUqW+hZ2AXVNQ2IqxHV1TX/4jl+y9od6Rp/o1oZmHdtRmyJ/Ko4Gb9+vWYO3cuPvjgA6SmpuLtt9/GZ599hnPnziEsLKzd8Tk5OVi4cCHOnTunvU0QBISHh1v0fO4Y3PjKuq8tMyOZk+Ixvn8ffH3+Gpbvu+CUDxZTW041BdZWHyqz6XENKw6vL6xA1sZSp5fN1/2la2r7+VN39sOSGYMA6C8tAUB5TSP+e+Jyh0UEDZf+ymoa0M2/k14Q6QmVlnUDNc1rseuUEjl5jq2cTZ7PD8Dm27Owur/jfeV3vtQ8KrhJTU3F6NGj8d577wEAWltboVAosGDBAixevLjd8Tk5OXjhhRdQV1dn0/O5W3CzvrACWZtK0Sr6TqSvaZS550y1Rduxt2aO1Wuweam2AU0/teLC1ZvYXlqlTRSU+o08oX8okmN6IqmvDHvOXEVugX0VgY39fJUqNV7fdgbbHLwMp8vww9pYgKHpbQUY7wmkVKkxbuneDmee/r977sD5qzextfhKuxosi6cnoGdQF5fVTbFGRqoCCya3Bbye1urAk+kmAs/Rqejt6qVje6TGhaCw/Lr2345uew7dLe2a2WTdPwh8PRDymOCmubkZQUFB2LBhA9LT07W3z5s3D3V1ddi6dWu7c3JycvDEE08gKioKra2tGDFiBN544w0MGTLE6HM0NTWhqalJ+319fT0UCoVbBDfGPiA025R95U1sadKxpkKvYZ8d4OcPygeSI90iZ8YczZKPYa6PM2cwDJtyvvHFaawyMhs1JSGsXbKybsn/g99e0wbmtpqZHInHxsWislZtNnnaXaTGhaCg7LrVY5w4IBQtojQ1kbzVtEHhSIyWofZmM/rp5JVpZg0N/83Yu1TsaTpq2+ELOT8eE9xcuXIFUVFRyMvLQ1pamvb2P/zhDzhw4ACOHDnS7pz8/Hx89913GDZsGFQqFf73f/8XBw8exKlTp9C3b992x7/88st45ZVX2t3uDsFN3oUaZKxuf42abcq+QooeVX4A3rm9WwfQz5Fx1nKWpdKTI/H2b4br3ba+sAKLNpY6bQy67zFLZ2EMDQzvjnPVNyUZz1N3xuHR8XEA2n52X52pxuclV9Aqtv1SB37+C17z/xp+AO6I6I6zVdKMxVHmpcUgPqwbymoaEdBZwMnL9Qx2zDBWjdwUzZL3usIK7XvGnf7NO8LPvekqsbagsl31c91jvGXmx6uDG0O3bt3CoEGDMGfOHLz22mvt7ufMjWeQskeV4T9o4OdgZ/+5q/is6LIUQ7bLpIQ+WPOIftK84S9oABgX3wuJfWVo+knExas3ceA7y5I7/QAsmt629GRYFNDYe2x9YYXLl4eM1SAxzPXR/f8gfz9U1qoBAQjs4ofHPypy1dBtoukHVVR+Hf89cQVfnqr2+g9kW1naesHce0Y3Ob6TIOAP9w5EkH8n7P/2GvaeueoTr73mdQQ8c3bHY4IbW5aljPnVr36Fzp07Y+3atR0e6445N5pOvp0EAW/MGur1OTfmSL1EIwB48vasgG4vKkd3M7dEQkR3TLyjD5pbRPh3EtDcIqJ3N3+UXlZh1ynrCxoOlQdj3IDe6NqlEyYnhCFJ0TaLpXu9pt5jts7eOIKmO7uxXB9duvlqniojVYHZoxTa3ApN8UN3m210F9bM5hijG/yYWubq2sUPJypV8O/ih63FV/CtRLOT7sTY7I5hvo87trTwmOAGaEsoTklJwbvvvgugLaE4Ojoa8+fPN5pQbKilpQVDhgzBfffdh7///e8dHu9uwQ1g+h+cr3LELIJhMq/mNffmDxLdTuIA0Ot2LyBj7zFTS6TuQvOhpkmuVDf/hCf+XeRVSb26ORWKkEBU1qpxrOI6/vV1uauH5pZmJkXigWQ5iivrENC5E2RBXbT3SfmBXFJ5HUfLryM2NAh7zlyzucilp9N0rzeW8FxR2whBEPRKajjis8yjgpv169dj3rx5WLlyJVJSUvD222/j008/xdmzZxEeHo65c+ciKioK2dnZAIBXX30VY8aMQf/+/VFXV4dly5Zhy5YtKCoqwuDBgzt8PncMbqg9zV9SUiaZCgBenTkEUweHG/2rrU7djJAgf+1fbsXf17Wr8TFtcBgS5MG4UqfGhmOXIYptS0ATB/bBgW+vuf0swv2JEXhyQj/trI5GRzM3qXEhOFLm3B5gvkwAMGtEFDYdu+yVgbezzEyKxGPjY7UfvlIEPLq/L/689ZTb/5t3BUft/PWo4AYA3nvvPW0Rv+TkZLzzzjtITU0FANx1112IjY1FTk4OAOB//ud/sGnTJlRVVSEkJAQjR47EX//6VwwfPtzMM/zMXYMb1j0wzTD4GBETgqv1P9q8HVcAsPQhy/7h6U5Xawr6/etwGf55uEybuKjZqXW0vBZ+goC+IYFuv7yQEhuCf8wZrldzo/SyCn/bcQ4togg/AL9JVWBcfKh2tmflwQvI3t5xU89x8b3QpZMf9vt48TdyT5oZCCmCHcO0gmlDwrHzVJU24DHc9u1LjO0MtZfHBTfO5I7BjS/WupGC7i8Wa3dHGG6HNkf3w99YKwkBgCDA6M9PNzjaXqrEF6VVVozS8YZFBaP0Sr02SExPluPuwRHtlq8sqe3y1/QhmDIoXBswpWXvdfDofVN6cqTdSff0M2M5J9YEPYZpBaa+D/L38/gaPdbSLQYqBQY3ZrhbcMMdU/Yx3B2hmeF5aeupDmd1DCsGGz5uWU0D8s7X6JVWt4TutnTDn+FznxRhu5sFOMY8pZOE3VEOlCAAS40E5CsPXGi3U8vTpMSGIKZ3kFvssCPnmjY4DJEhQegX2g3D+sokW9rSnYkG2vKD3LFkhRSs+SPSEgxuzHC34Ia1bhxDd1bHHE3SrW6CnC0BjTGmZuFKKq9j6/EraGj+CSHduqD5JxHNLS345JtKi365CQBmJsvRq1sAenf3R2zvbuh7OwG1Tt2MM8obkuUppcaGoKDceNE6Tb8szWyNMZYuZRF5knsGheOB4ZHaulpStFYwLEz4/v4LXrGcJeVnGYMbM9wtuOHMjeNoZnVOXK5z2QesNT9LSwKyCQNCcei7Gr2CXYunJyCxr0zvl6nhX4cbii6juLLOzqvRp9s7yhRTicruUGQtPTkSi6Yn4ONvLllUJZvIHAFAik4FawHAcwZb1431WDP1u0F3OUvTbLeyVo1LtQ04VlGHfWevekTwo2mfIwUGN2a4W3ADsNaNM5hqEOkM1vzlortFXfcvt/SkSDw6Phbpy/NMBgUd5Wu9vPUkcvKla/b4/OT+mJMabTZwc6ct5n6386J0v9e8XisPXjCaT0UklUER3XG2+qbejLCfACy6t/0fJ5bQDX7cuX2JueV/azG4McMdgxtA/43qLaWy3Ymz+zdp2LJjwFS+T4IFLQY0XYhNvYcs7eVlDcMaNIYzSO5SHDC2VyDKa9V6t+m+Xt38O2F94fc+W8eEXMuwQrctjO3u1K167gdgtJPLOizPGI4ZwxjcOJy7BjcAd005mqtaDFhaOh6QtuquqfeQoys0Gzb4O/jtNWRtLEWrY55OMgKAuWNiUFnXiL1nr7l6OOSjJgwIxd1DwqFS38IPN5u1Cc0l39ehrKbRpgRnYzu4NEFQ35BArC/8Xq/ti1QEAHkSbgdncGOGuwY3zL1xDmuLA85Li8G9Q+Xade8Tl+v0asE8MSEOqXG9LKqWm2Gio6/u2KSe5TD1HjKc0nZkk9Gs6QkY068XZi7Pk/iR28wbE4OPvpFuuY3I04yN741F9w5EWHDXDtuWmGL4O8FwN5ctCc6W5OVZg8GNGe4a3HDXlPMZFgfU/QesaTxpbIrY8K8gW/JKsow8tqPyU6zN+Skqv45LtQ344WYz/CXqXj0vLQb+nf2w+lCZXY8DtPVjGiwP1hZ0lMsCvWLbOZHUpg0OgyzIHxCBxL4yRPbsqm1XERvazap2CcbKbnx1phqfl1zRFjQF2jYKmPv9aQ8GN2a4a3Bj7K92R1R4JPNs6fNl64xLerIcUwdHaP/CKqm8bjZhWJefADw4PAqbj13ucLknc1I8XpyWYN3goF81G2hbu5eiAFn/Pt1woaYBomj5rilTxQV16S63uXI31sykSGwtYZE98iwjY3pi0sAwQAAqfmjUBkTGlsCUKrV2hkhxuyJ7kL8fKmob4ScIZv+d2oPBjRnuGtwA7XNCrGkTQK5laV0dU1J1tpB25KkJcXh0XJz2l8y7e853mASbkarAgsmW5f0A7fO/Hhwehc3HL2sDuEhZV1xR/WjRY5mi6XMVFtzVphk0Y4z9dZl/8Qd8coRJwkRSGNuvF/Iu1urdlqyQoaRSpf39lXlXPF681/o/qDrC4MYMdw5umHfj2XQ/WD8vuSLZ1mJjfZ4MWZIkbKw1hLFiY/bk/tgyY6KZwVKEBGpL4Gseq6dBKXx7CqRJNfNERB1LVsiw4rcj2VvKWdw5uGHejXfRTV62debgpRmDcN8wucU9sIrKr2PB2uOmWyUA+HDeSOw5cxVrC9oqIhsGPfbk/vxyRBQmDuyDbSVK7DpdbdNjGHPPoHCEBge0BSd27CZ0RLd5IjJO6tUHBjdmuHNwY+ovZqkzzsn5bJk5sLUviy3JtZr8LgB4Z893WFtQadX5xiQrZDjxvcqhNW5emzmkXZKkpbtEDBPK+4YE4osTVfjw8EWLxuwOVZaJ3J2U/aUY3JjhzsENYPyDiYnF3kOpUmPN4XKsOnTR7HGmmlFaypaKu4MieuBM1Q2bns+c+xMjENojAB/lXXJaMJA1PQGRPbvavSW2orYRFbWN2Hf2Goou/ZwTNW9MDEbFhcBPELy26SGRVKRafWBwY4a7BzemlgSkbh1PrmVqJiejg9waa5/j9W1nsK1Uad9gJTJtcBiiQoJw+bpa0iUrS3RUY8jQyoMXsHTH2Q5rFwkAnrwzDqn9eqGkUoWw4AAkRskcVhSNyNNw5sZJ3D24MdUmQACwRcIGZOQeDMulSz07J2XbCUEApg+JwM5TVWgV25LdJ9wRin3nPKua75SEPshIjUZjc0u77a1lNQ348mSVzT24dEvo6/YJM5zZ4ZIW+Yr05Ei8/ZvhkjwWgxsz3D24AYA3vjiNVUaKndm7VEG+yZ62EwKAOQazSYa1gBzdzsEZhsh74LTyhmQBR+akePx2TIy2A3RFbSNU6lva3J6S7+tw4Nsa7DlzVaJnJHJPz0/uj9/dM1CSx2JwY4YnBDfmtuIy/4ZsYdhLxpIuwtbUxjE3S0FtBAApTm5aSORqj4yNwcsPDJXksRjcmOEJwQ1wu4iaiWaDGSnReGNWotPHRN5Hk+C8+tBFvYDEWHsIax6zqPw69pypxuZi+yr1CgCmD43ArlPVaBFFvRLvROT+mHPjJJ4S3ABASeV1k80Gra04S2SOo3J/bNm1BUDblFS3ErNu5WHN/1+t/xFHy69jVGwIvimrRfZ29pcicjfcLeUEnhTcAKbzbwD95EUid6VbT+aM8gbWFlS066GmqcDc93afGmt6exk+11enq1Fzswkq9S3k5LFbOJGrbZVoMwyDGzM8LbixZLeLrY0RiVxBt46MPYGMpc/17p7z3JZN5EKcuXECTwtuAMsqzs5Li8G0oRFW99wh8gWagOrE5Tr8bcc5bf6O7i+/cfG9MLZ/KGJ7d9POIAX5+6GyVq2XiK3b4JPJ00TmCQDyJNoEw+DGDE8MbgDrchcyUhRYMIX5OETGmMrfsXUZTHfJzXD3mbEOykS+ZEpCGP75yGhJHovBjRmeGtwAP0+x5xZY1oQxI0WBQZFt1xhi0F2ZiKRnLDHbsIfVGWU93t9/Aa0ijO7+8gPw7F3xGCQP1ut7VVmrxldnqvF5yRXtuT71y5s80l/Th+C3Y2IleSwGN2Z4cnCjsWzXWSzfd8GmczUBT0iQPxQhgaiobbSp/w4R2c7Y7JGlOUiG52qCKd2gSUM3eDL8/5nJcnQL6MLu6ORQ+RLWZWNwY4Y3BDeAfQGOKRkpCswerUBFbSPqbldTZQBE5DmMJWsDMLsMZzjbBKDdTJMluUUZqQoMlv88U6ybo2RsyY68n5T5NgCDG7O8JbgB4JKy9+YCoDr1LQDQ3tbQ3MIEZyIvYLi0phsEWVobSfcxALRbojNcjtMcY5jIrfu97uOYC8AMZ63m3P49ZrjUR9KTaqcUwODGLG8KbgDPKHtvGBABaBcUdfS94TmcSSLyDoa9yux5HN0WI5rdbsZmsAyfR3fGy1Qgpfu94XN0FHxZEqB54268ToKAw4sncebGGbwtuNGl+cfdUc8gb5J5VzwS5D0sDpqcdUxHwZdSpcbR8lqLAjtj30sR2Gm6YGsaO9p6ndbO0mmuXXOuLUFvQ3MLuvl3sml20Nh1W/LchscY+xlL8ZrqHjPy9gxJWU0D4kK7af9fc+32XoMjjtH8TAzHbcvP3Nj7y97X2NR7xpL3heZnbvhzMPaz6eg2w/839h42nDGzJUiS8pj1hd9ra0Zpim82NrXoJbkDbTNknQQBb8waKmmjZwY3ZnhzcKPLcAqYa96uYWwZ76yyHu9JkC+lG9hZ+wG158xVbC2+Iun7QTPdb5iwrjseqa7d8Hmfs/C1WF9YibUFlZJet+bn4IjXFNDfFeXLO6Q0jUcLyq5L8hqkJ8sxdXCETe8LYz8HW27T/X/d8dg6o+2MYwK7+KGkUgX/zn6IDe0Gxe0u92U1jejdzR+yoC4QAPR0wA5djwtuli9fjmXLlqGqqgpJSUl49913kZKSYvL4zz77DC+99BLKy8sxYMAAvPnmm7jvvvssei5fCW6MMfZXwPrC77G2gEEPERFJy08AsmclSjZ741HBzfr16zF37lx88MEHSE1Nxdtvv43PPvsM586dQ1hYWLvj8/LyMGHCBGRnZ+P+++9Hbm4u3nzzTRw7dgxDh3bcVt2XgxtTDNeqjU1FMgAiIiJrSZl341HBTWpqKkaPHo333nsPANDa2gqFQoEFCxZg8eLF7Y6fPXs2GhoasG3bNu1tY8aMQXJyMj744IN2xzc1NaGpqUn7fX19PRQKBYMbK3UUAFm7e4GIiHyDK3pLdbb72ezQ3NyMoqIiZGVlaW/z8/PD1KlTkZ+fb/Sc/Px8/O53v9O7bdq0adiyZYvR47Ozs/HKK69INmZfJZcF4v6knyNvww6vht/PGBaJh8fEGA2IgI6T2swluekmtRERkfvqJAja3WrO5NLgpqamBi0tLQgPD9e7PTw8HGfPGm8UWVVVZfT4qqoqo8dnZWXpBUOamRtyvI4CImO3dfS95rYFU/q327oJOH63gKU7CixZxtNUib17cITFgZ4janJkmij1b83OCWsTXQ1rjVgT9BqrxGvvdVvy3LrHdBRg2/qa6h5zRnkDawsqTFYctqcujKOOMTZjq3lvWPsz7+j9ZctrbMmMsqn3heF4ND8HYz+bju43fG28lWbHlCtKdrh0WerKlSuIiopCXl4e0tLStLf/4Q9/wIEDB3DkyJF25/j7++Ojjz7CnDlztLe9//77eOWVV1BdXd3hczLnhpyho2U8S8rsm3vsjmpyAJYFCpYUX7NkLLqtADoajz3Xbuw1sLbWiKVF56wZg5SvqannsKReizswVvHY1vGaajVhz2tsanu1JY/bUdsM3Ws1d7/hbZZu93bFH2u2HiPFv3NDHpNz09zcjKCgIGzYsAHp6ena2+fNm4e6ujps3bq13TnR0dH43e9+hxdeeEF721/+8hds2bIFJSUlHT4ngxsiIiLPY83nt5+TxmSUv78/Ro4ciT179mhva21txZ49e/RmcnSlpaXpHQ8Au3fvNnk8ERER+RaX5twAwO9+9zvMmzcPo0aNQkpKCt5++200NDTg0UcfBQDMnTsXUVFRyM7OBgAsXLgQEydOxFtvvYUZM2Zg3bp1OHr0KFatWuXKyyAiIiI34fLgZvbs2bh27Rr+/Oc/o6qqCsnJydi5c6c2abiiogJ+fj9PMI0dOxa5ubn405/+hCVLlmDAgAHYsmWLRTVuiIiIyPu5vM6NszHnhoiIyPN4TM4NERERkdQY3BAREZFXYXBDREREXoXBDREREXkVBjdERETkVRjcEBERkVdhcENERERexeVF/JxNU9anvr7exSMhIiIiS2k+ty0pz+dzwc2NGzcAAAqFwsUjISIiImvduHEDMpnM7DE+V6G4tbUVV65cQY8ePSAIgqSPXV9fD4VCgcrKSp+sfuzr1w/wNfD16wf4GvD6ffv6Ace9BqIo4saNG4iMjNRry2SMz83c+Pn5oW/fvg59juDgYJ99UwO8foCvga9fP8DXgNfv29cPOOY16GjGRoMJxURERORVGNwQERGRV2FwI6GAgAD85S9/QUBAgKuH4hK+fv0AXwNfv36ArwGv37evH3CP18DnEoqJiIjIu3HmhoiIiLwKgxsiIiLyKgxuiIiIyKswuCEiIiKvwuBGIsuXL0dsbCy6du2K1NRUFBQUuHpINjl48CB+8YtfIDIyEoIgYMuWLXr3i6KIP//5z5DL5QgMDMTUqVPx3Xff6R1TW1uLhx9+GMHBwejZsycef/xx3Lx5U++YEydO4M4770TXrl2hUCjwt7/9zdGXZpHs7GyMHj0aPXr0QFhYGNLT03Hu3Dm9Y3788UdkZmaid+/e6N69Ox566CFUV1frHVNRUYEZM2YgKCgIYWFhePHFF/HTTz/pHbN//36MGDECAQEB6N+/P3Jychx9eRZZsWIFhg0bpi3AlZaWhh07dmjv9/brN7R06VIIgoAXXnhBe5u3vwYvv/wyBEHQ+0pISNDe7+3XDwCXL1/Gb3/7W/Tu3RuBgYFITEzE0aNHtfd78+/C2NjYdj9/QRCQmZkJwEN+/iLZbd26daK/v7/4r3/9Szx16pT45JNPij179hSrq6tdPTSrbd++XfzjH/8obtq0SQQgbt68We/+pUuXijKZTNyyZYtYUlIiPvDAA2JcXJyoVqu1x9x7771iUlKS+M0334iHDh0S+/fvL86ZM0d7v0qlEsPDw8WHH35YPHnypLh27VoxMDBQXLlypbMu06Rp06aJa9asEU+ePCkWFxeL9913nxgdHS3evHlTe8wzzzwjKhQKcc+ePeLRo0fFMWPGiGPHjtXe/9NPP4lDhw4Vp06dKh4/flzcvn27GBoaKmZlZWmPuXjxohgUFCT+7ne/E0+fPi2+++67YqdOncSdO3c69XqN+fzzz8UvvvhC/Pbbb8Vz586JS5YsEbt06SKePHlSFEXvv35dBQUFYmxsrDhs2DBx4cKF2tu9/TX4y1/+Ig4ZMkRUKpXar2vXrmnv9/brr62tFWNiYsRHHnlEPHLkiHjx4kVx165d4vnz57XHePPvwqtXr+r97Hfv3i0CEPft2yeKomf8/BncSCAlJUXMzMzUft/S0iJGRkaK2dnZLhyV/QyDm9bWVjEiIkJctmyZ9ra6ujoxICBAXLt2rSiKonj69GkRgFhYWKg9ZseOHaIgCOLly5dFURTF999/XwwJCRGbmpq0xyxatEgcOHCgg6/IelevXhUBiAcOHBBFse16u3TpIn722WfaY86cOSMCEPPz80VRbAsQ/fz8xKqqKu0xK1asEIODg7XX/Ic//EEcMmSI3nPNnj1bnDZtmqMvySYhISHihx9+6FPXf+PGDXHAgAHi7t27xYkTJ2qDG194Df7yl7+ISUlJRu/zhetftGiROH78eJP3+9rvwoULF4rx8fFia2urx/z8uSxlp+bmZhQVFWHq1Kna2/z8/DB16lTk5+e7cGTSKysrQ1VVld61ymQypKamaq81Pz8fPXv2xKhRo7THTJ06FX5+fjhy5Ij2mAkTJsDf3197zLRp03Du3Dlcv37dSVdjGZVKBQDo1asXAKCoqAi3bt3Sew0SEhIQHR2t9xokJiYiPDxce8y0adNQX1+PU6dOaY/RfQzNMe72nmlpacG6devQ0NCAtLQ0n7r+zMxMzJgxo904feU1+O677xAZGYl+/frh4YcfRkVFBQDfuP7PP/8co0aNwq9+9SuEhYVh+PDhWL16tfZ+X/pd2NzcjI8//hiPPfYYBEHwmJ8/gxs71dTUoKWlRe+HCADh4eGoqqpy0agcQ3M95q61qqoKYWFhevd37twZvXr10jvG2GPoPoc7aG1txQsvvIBx48Zh6NChANrG5+/vj549e+oda/gadHR9po6pr6+HWq12xOVYpbS0FN27d0dAQACeeeYZbN68GYMHD/aZ61+3bh2OHTuG7Ozsdvf5wmuQmpqKnJwc7Ny5EytWrEBZWRnuvPNO3Lhxwyeu/+LFi1ixYgUGDBiAXbt24dlnn8Xzzz+Pjz76CIBv/S7csmUL6urq8MgjjwDwnPe/z3UFJ7JUZmYmTp48icOHD7t6KE43cOBAFBcXQ6VSYcOGDZg3bx4OHDjg6mE5RWVlJRYuXIjdu3eja9eurh6OS0yfPl37/8OGDUNqaipiYmLw6aefIjAw0IUjc47W1laMGjUKb7zxBgBg+PDhOHnyJD744APMmzfPxaNzrn/+85+YPn06IiMjXT0Uq3Dmxk6hoaHo1KlTu0zx6upqREREuGhUjqG5HnPXGhERgatXr+rd/9NPP6G2tlbvGGOPofscrjZ//nxs27YN+/btQ9++fbW3R0REoLm5GXV1dXrHG74GHV2fqWOCg4Pd4sPD398f/fv3x8iRI5GdnY2kpCT84x//8InrLyoqwtWrVzFixAh07twZnTt3xoEDB/DOO++gc+fOCA8P9/rXwFDPnj1xxx134Pz58z7xHpDL5Rg8eLDebYMGDdIuzfnK78JLly7hq6++whNPPKG9zVN+/gxu7OTv74+RI0diz5492ttaW1uxZ88epKWluXBk0ouLi0NERITetdbX1+PIkSPaa01LS0NdXR2Kioq0x+zduxetra1ITU3VHnPw4EHcunVLe8zu3bsxcOBAhISEOOlqjBNFEfPnz8fmzZuxd+9exMXF6d0/cuRIdOnSRe81OHfuHCoqKvReg9LSUr1fbLt370ZwcLD2F2ZaWpreY2iOcdf3TGtrK5qamnzi+qdMmYLS0lIUFxdrv0aNGoWHH35Y+//e/hoYunnzJi5cuAC5XO4T74Fx48a1KwHx7bffIiYmBoBv/C4EgDVr1iAsLAwzZszQ3uYxP39J0pJ93Lp168SAgAAxJydHPH36tPjUU0+JPXv21MsU9xQ3btwQjx8/Lh4/flwEIP79738Xjx8/Ll66dEkUxbbtjz179hS3bt0qnjhxQpw5c6bR7Y/Dhw8Xjxw5Ih4+fFgcMGCA3vbHuro6MTw8XPx//+//iSdPnhTXrVsnBgUFuXz7oyiK4rPPPivKZDJx//79elshGxsbtcc888wzYnR0tLh3717x6NGjYlpampiWlqa9X7MN8p577hGLi4vFnTt3in369DG6DfLFF18Uz5w5Iy5fvtxttsEuXrxYPHDggFhWViaeOHFCXLx4sSgIgvjll1+Kouj912+M7m4pUfT+1+D3v/+9uH//frGsrEz8+uuvxalTp4qhoaHi1atXRVH0/usvKCgQO3fuLL7++uvid999J37yySdiUFCQ+PHHH2uP8fbfhS0tLWJ0dLS4aNGidvd5ws+fwY1E3n33XTE6Olr09/cXU1JSxG+++cbVQ7LJvn37RADtvubNmyeKYtsWyJdeekkMDw8XAwICxClTpojnzp3Te4wffvhBnDNnjti9e3cxODhYfPTRR8UbN27oHVNSUiKOHz9eDAgIEKOiosSlS5c66xLNMnbtAMQ1a9Zoj1Gr1eJzzz0nhoSEiEFBQeKDDz4oKpVKvccpLy8Xp0+fLgYGBoqhoaHi73//e/HWrVt6x+zbt09MTk4W/f39xX79+uk9hys99thjYkxMjOjv7y/26dNHnDJlijawEUXvv35jDIMbb38NZs+eLcrlctHf31+MiooSZ8+erVfjxduvXxRF8b///a84dOhQMSAgQExISBBXrVqld7+3/y7ctWuXCKDdNYmiZ/z8BVEURWnmgIiIiIhcjzk3RERE5FUY3BAREZFXYXBDREREXoXBDREREXkVBjdERETkVRjcEBERkVdhcENERERehcENEREReRUGN0RERORVGNwQkdu4du0ann32WURHRyMgIAARERGYNm0avv76awCAIAjYsmWLawdJRG6vs6sHQESk8dBDD6G5uRkfffQR+vXrh+rqauzZswc//PCDq4dGRB6EMzdE5Bbq6upw6NAhvPnmm5g0aRJiYmKQkpKCrKwsPPDAA4iNjQUAPPjggxAEQfs9AGzduhUjRoxA165d0a9fP7zyyiv46aeftPcLgoAVK1Zg+vTpCAwMRL9+/bBhwwbt/c3NzZg/fz7kcjm6du2KmJgYZGdnO+vSiUhiDG6IyC10794d3bt3x5YtW9DU1NTu/sLCQgDAmjVroFQqtd8fOnQIc+fOxcKFC3H69GmsXLkSOTk5eP311/XOf+mll/DQQw+hpKQEDz/8MH7zm9/gzJkzAIB33nkHn3/+OT799FOcO3cOn3zyiV7wRESehV3BichtbNy4EU8++STUajVGjBiBiRMn4je/+Q2GDRsGoG0GZvPmzUhPT9eeM3XqVEyZMgVZWVna2z7++GP84Q9/wJUrV7TnPfPMM1ixYoX2mDFjxmDEiBF4//338fzzz+PUqVP46quvIAiCcy6WiByGMzdE5DYeeughXLlyBZ9//jnuvfde7N+/HyNGjEBOTo7Jc0pKSvDqq69qZ366d++OJ598EkqlEo2Njdrj0tLS9M5LS0vTztw88sgjKC4uxsCBA/H888/jyy+/dMj1EZFzMLghIrfStWtX3H333XjppZeQl5eHRx55BH/5y19MHn/z5k288sorKC4u1n6Vlpbiu+++Q9euXS16zhEjRqCsrAyvvfYa1Go1fv3rX+OXv/ylVJdERE7G4IaI3NrgwYPR0NAAAOjSpQtaWlr07h8xYgTOnTuH/v37t/vy8/v5V9w333yjd94333yDQYMGab8PDg7G7NmzsXr1aqxfvx4bN25EbW2tA6+MiByFW8GJyC388MMP+NWvfoXHHnsMw4YNQ48ePXD06FH87W9/w8yZMwEAsbGx2LNnD8aNG4eAgACEhITgz3/+M+6//35ER0fjl7/8Jfz8/FBSUoKTJ0/ir3/9q/bxP/vsM4waNQrjx4/HJ598goKCAvzzn/8EAPz973+HXC7H8OHD4efnh88++wwRERHo2bOnK14KIrKXSETkBn788Udx8eLF4ogRI0SZTCYGBQWJAwcOFP/0pz+JjY2NoiiK4ueffy72799f7Ny5sxgTE6M9d+fOneLYsWPFwMBAMTg4WExJSRFXrVqlvR+AuHz5cvHuu+8WAwICxNjYWHH9+vXa+1etWiUmJyeL3bp1E4ODg8UpU6aIx44dc9q1E5G0uFuKiLyesV1WROS9mHNDREREXoXBDREREXkVJhQTkdfj6juRb+HMDREREXkVBjdERETkVRjcEBERkVdhcENERERehcENEREReRUGN0RERORVGNwQERGRV2FwQ0RERF7l/wcqe5kHQhmQ2wAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "\n", "plt.plot(loss_monitor.loss, '.')\n", "plt.xlabel('Steps')\n", "plt.ylabel('Loss')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The method of printing the parameters of the quantum embedded layer is as follows:" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ 8.11327994e-02, -3.34400564e-01, -1.23247825e-01, 5.81944704e-01,\n", " -4.20968421e-03, 3.15563884e-05, 2.42589042e-01, 8.80479038e-01,\n", " -1.43023849e-01, -6.37480104e-03, 2.73182592e-03, 1.65943671e-02,\n", " 2.39036694e-01, -2.39808977e-01, -6.56178296e-01, 2.62607052e-03,\n", " -9.76558731e-05, -7.48617807e-03, 4.85512346e-01, 8.62547606e-02,\n", " 1.09600239e-02, -1.94667071e-01, 5.48206130e-03, 2.82003220e-05,\n", " 2.83775508e-01, -3.44718695e-01, 2.57234443e-02, -1.58091113e-01,\n", " -5.39550185e-03, -1.15225427e-02, 2.88938046e-01, -5.74903965e-01,\n", " -2.53041506e-01, -1.81123063e-01, -5.67151117e-04, -3.33190081e-03,\n", " 3.47066782e-02, 2.39473388e-01, 1.34246838e+00, -9.32823777e-01,\n", " 1.55618461e-03, 1.34847098e-04, 7.36262277e-02, -1.90044902e-02,\n", " -1.26371592e-01, 4.32286650e-01, -3.66644454e-05, -1.36820097e-02,\n", " 7.11344108e-02, -3.02037269e-01, -1.80939063e-01, 4.20952231e-01,\n", " -6.96726423e-03, -3.31268320e-03, 2.85857711e-02, 2.78895229e-01,\n", " -2.74261057e-01, 1.94433972e-01, -1.66424108e-03, -2.27207807e-03,\n", " 6.26490265e-02, -1.98727295e-01, -1.25026256e-01, -1.52513385e-01,\n", " -5.60277607e-03, -7.44100334e-03, 4.44238521e-02, -6.64802119e-02,\n", " 1.55135123e-02, -1.33805767e-01, 1.74699686e-02, -1.28326667e-02],\n", " dtype=float32)" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "net.embedding.weight.asnumpy()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Classical Word Embedding Layer\n", "\n", "Here, we construct a classical CBOW neural network with the classical word embedding layer. This classical CBOW is compared with the quantum one.\n", "\n", "Firstly, we construct the classical CBOW neural network and the parameters are similar to the ones in the quantum CBOW." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "class CBOWClassical(nn.Cell):\n", " def __init__(self, num_embedding, embedding_dim, window, hidden_dim):\n", " super(CBOWClassical, self).__init__()\n", " self.dim = 2 * window * embedding_dim\n", " self.embedding = nn.Embedding(num_embedding, embedding_dim, True)\n", " self.dense1 = nn.Dense(self.dim, hidden_dim)\n", " self.dense2 = nn.Dense(hidden_dim, num_embedding)\n", " self.relu = ops.ReLU()\n", " self.reshape = ops.Reshape()\n", "\n", " def construct(self, x):\n", " embed = self.embedding(x)\n", " embed = self.reshape(embed, (-1, self.dim))\n", " out = self.dense1(embed)\n", " out = self.relu(out)\n", " out = self.dense2(out)\n", " return out" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Generate the dataset for the classical CBOW neural network." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "train_x shape: (58, 4)\n", "train_y shape: (58,)\n" ] } ], "source": [ "train_x = []\n", "train_y = []\n", "for i in sample:\n", " around, center = i\n", " train_y.append(word_dict[center])\n", " train_x.append([])\n", " for j in around:\n", " train_x[-1].append(word_dict[j])\n", "train_x = np.array(train_x).astype(np.int32)\n", "train_y = np.array(train_y).astype(np.int32)\n", "print(\"train_x shape: \", train_x.shape)\n", "print(\"train_y shape: \", train_y.shape)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Train the classical CBOW network." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "epoch: 25 step: 20 time: 0.022, loss is 0.627\n", "epoch: 50 step: 20 time: 0.028, loss is 0.011\n", "epoch: 75 step: 20 time: 0.026, loss is 0.003\n", "epoch: 100 step: 20 time: 0.022, loss is 0.002\n", "epoch: 125 step: 20 time: 0.017, loss is 0.001\n", "epoch: 150 step: 20 time: 0.021, loss is 0.001\n", "epoch: 175 step: 20 time: 0.027, loss is 0.000\n", "epoch: 200 step: 20 time: 0.019, loss is 0.000\n", "epoch: 225 step: 20 time: 0.019, loss is 0.000\n", "epoch: 250 step: 20 time: 0.019, loss is 0.000\n", "epoch: 275 step: 20 time: 0.018, loss is 0.000\n", "epoch: 300 step: 20 time: 0.025, loss is 0.000\n", "epoch: 325 step: 20 time: 0.018, loss is 0.000\n", "epoch: 350 step: 20 time: 0.017, loss is 0.000\n", "Total time used: 8.476526975631714\n" ] } ], "source": [ "ms.set_context(mode=ms.GRAPH_MODE, device_target=\"CPU\")\n", "\n", "train_loader = ds.NumpySlicesDataset({\n", " \"around\": train_x,\n", " \"center\": train_y\n", "}, shuffle=False).batch(3)\n", "net = CBOWClassical(len(word_dict), embedding_dim, window_size, hidden_dim)\n", "net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')\n", "net_opt = nn.Momentum(net.trainable_params(), 0.01, 0.9)\n", "loss_monitor = LossMonitorWithCollection(500)\n", "model = ms.Model(net, net_loss, net_opt)\n", "model.train(350, train_loader, callbacks=[loss_monitor], dataset_sink_mode=False)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Print the loss value during convergence:" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "\n", "plt.plot(loss_monitor.loss, '.')\n", "plt.xlabel('Steps')\n", "plt.ylabel('Loss')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "According to the above result, it can be seen that the quantum word embedding model generated by the quantum simulation can complete the word embedding task perfectly. When classical computers cannot handle the large quantity of data, the quantum computers can easily deal with large data." ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", " \n", " \n", "\n", "\n", "
SoftwareVersion
mindquantum0.9.11
scipy1.10.1
numpy1.23.5
SystemInfo
Python3.9.16
OSLinux x86_64
Memory8.3 GB
CPU Max Thread8
DateMon Jan 1 01:34:10 2024
\n" ], "text/plain": [ "" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from mindquantum.utils.show_info import InfoTable\n", "\n", "InfoTable('mindquantum', 'scipy', 'numpy')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Reference\n", "\n", "[1] Tomas Mikolov, Kai Chen, Greg Corrado, Jeffrey Dean. [Efficient Estimation of Word Representations in Vector Space](https://arxiv.org/pdf/1301.3781.pdf)" ] } ], "metadata": { "kernelspec": { "display_name": "base", "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.9.16" } }, "nbformat": 4, "nbformat_minor": 2 }